Tidak mengandung huruf besar-kecil

Apakah ada cara untuk membuat pengembalian berikut ini benar?

string title = "ASTRINGTOTEST";
title.Contains("string");

Sepertinya tidak ada kelebihan yang memungkinkan saya untuk mengatur sensitivitas case .. Saat ini saya MENDUKUNG mereka berdua, tapi itu hanya konyol (yang saya maksudkan dengan masalah i18n yang datang dengan casing atas dan bawah).

PEMBARUAN
Pertanyaan ini sudah kuno dan sejak itu saya menyadari saya meminta jawaban sederhana untuk topik yang sangat luas dan sulit jika Anda ingin menyelidikinya sepenuhnya.
Untuk sebagian besar kasus, di mono-lingual, basis kode bahasa Inggris ini jawabannya akan cukup. Saya curiga karena kebanyakan orang yang datang ke sini termasuk dalam kategori ini, ini adalah jawaban yang paling populer. Namun jawaban
ini memunculkan masalah yang melekat bahwa kita tidak dapat membandingkan tidak peka huruf besar kecil sampai kita tahu kedua teks adalah budaya yang sama dan kita tahu apa budaya itu. Ini mungkin jawaban yang kurang populer, tetapi saya pikir itu lebih benar dan itulah sebabnya saya menandainya.

Untuk menguji apakah string paragraphberisi string word(terima kasih @QuarterMeister)

culture.CompareInfo.IndexOf(paragraph, word, CompareOptions.IgnoreCase) >= 0

Di mana culturecontoh CultureInfomenggambarkan bahasa tempat teks tersebut ditulis.

Solusi ini transparan tentang definisi tidak peka huruf besar-kecil, yang bergantung pada bahasa . Misalnya, bahasa Inggris menggunakan karakter Idan iuntuk versi huruf besar dan kecil dari huruf kesembilan, sedangkan bahasa Turki menggunakan karakter ini untuk huruf kesebelas dan kedua belas dari 29 huruf alfabet panjangnya. Versi huruf besar bahasa Turki dari 'i' adalah karakter asing 'İ'.

Jadi string tindan TINkata yang sama dalam bahasa Inggris , tetapi kata-kata yang berbeda dalam bahasa Turki . Seperti yang saya mengerti, yang satu berarti 'roh' dan yang lainnya adalah kata onomatopoeia. (Orang Turki, tolong koreksi saya jika saya salah, atau sarankan contoh yang lebih baik)

Sebagai rangkuman, Anda hanya bisa menjawab pertanyaan 'apakah kedua string ini sama tetapi dalam kasus yang berbeda' jika Anda tahu bahasa apa teks tersebut berada . Jika Anda tidak tahu, Anda harus mengambil tendangan. Mengingat hegemoni bahasa Inggris dalam perangkat lunak, Anda mungkin harus menggunakan CultureInfo.InvariantCulture, karena itu akan salah dengan cara yang akrab.

Anda bisa menggunakan Metode String.IndexOf dan lulus StringComparison.OrdinalIgnoreCasesebagai jenis pencarian untuk digunakan:

string title = "STRING";
bool contains = title.IndexOf("string", StringComparison.OrdinalIgnoreCase) >= 0;

Yang lebih baik adalah mendefinisikan metode ekstensi baru untuk string:

public static class StringExtensions
{
    public static bool Contains(this string source, string toCheck, StringComparison comp)
    {
        return source?.IndexOf(toCheck, comp) >= 0;
    }
}

Perhatikan, bahwa propagasi nol ?. tersedia sejak C # 6.0 (VS 2015), untuk penggunaan versi yang lebih lama

if (source == null) return false;
return source.IndexOf(toCheck, comp) >= 0;

PEMAKAIAN:

string title = "STRING";
bool contains = title.Contains("string", StringComparison.OrdinalIgnoreCase);

Anda bisa menggunakan IndexOf()seperti ini:

string title = "STRING";

if (title.IndexOf("string", 0, StringComparison.CurrentCultureIgnoreCase) != -1)
{
    // The string exists in the original
}

Karena 0 (nol) dapat berupa indeks, Anda mengecek terhadap -1.

MSDN

Posisi nilai indeks berbasis nol jika string itu ditemukan, atau -1 jika tidak. Jika nilainya String.Empty, nilai kembali adalah 0.

Solusi alternatif menggunakan Regex:

bool contains = Regex.IsMatch("StRiNG to search", Regex.Escape("string"), RegexOptions.IgnoreCase);

Anda selalu bisa menaikkan atau menurunkan string terlebih dahulu.

string title = "string":
title.ToUpper().Contains("STRING")  // returns true

Ups, lihat saja tadi. Perbandingan kasus yang sensitif *mungkin akan tetap *melakukan hal yang sama, dan jika kinerja tidak menjadi masalah, saya tidak melihat masalah dengan membuat salinan huruf besar dan membandingkannya. Saya bisa bersumpah bahwa saya pernah melihat membandingkan kasus-sensitif sekali ...

Hanya .NET Core 2.0+ (mulai sekarang)

.NET Core telah memiliki sepasang metode untuk menangani hal ini sejak versi 2.0:

• String.Contains (Char, StringComparison )
• String.Contains (String, StringComparison )

Contoh:

"Test".Contains("test", System.StringComparison.CurrentCultureIgnoreCase);

Pada waktunya, mereka mungkin akan masuk ke dalam .NET Standard dan, dari sana, ke semua implementasi lain dari Base Class Library.

Salah satu masalah dengan jawabannya adalah bahwa ia akan mengeluarkan pengecualian jika string adalah nol. Anda dapat menambahkannya sebagai cek agar tidak:

public static bool Contains(this string source, string toCheck, StringComparison comp)
{
    if (string.IsNullOrEmpty(toCheck) || string.IsNullOrEmpty(source))
        return true;

    return source.IndexOf(toCheck, comp) >= 0;
} 

Kelas StringExtension adalah jalan maju, saya telah menggabungkan beberapa posting di atas untuk memberikan contoh kode lengkap:

public static class StringExtensions
{
    /// <summary>
    /// Allows case insensitive checks
    /// </summary>
    public static bool Contains(this string source, string toCheck, StringComparison comp)
    {
        return source.IndexOf(toCheck, comp) >= 0;
    }
}

Ini bersih dan sederhana.

Regex.IsMatch(file, fileNamestr, RegexOptions.IgnoreCase)

OrdinalIgnoreCase, CurrentCultureIgnoreCase, atau InvariantCultureIgnoreCase?

Karena ini tidak ada, berikut adalah beberapa rekomendasi tentang kapan harus menggunakan yang mana:

Dos

• Menggunakan StringComparison.OrdinalIgnoreCase untuk perbandingan sebagai standar aman Anda untuk pencocokan string agnostik kultur.
• Gunakan StringComparison.OrdinalIgnoreCaseperbandingan untuk meningkatkan kecepatan.
• Gunakan StringComparison.CurrentCulture-basedoperasi string saat menampilkan output ke pengguna.
• Beralih penggunaan operasi string saat ini berdasarkan pada budaya invarian untuk menggunakan non-linguistik StringComparison.Ordinalatau StringComparison.OrdinalIgnoreCaseketika perbandingan secara
  linguistik tidak relevan (simbolis, misalnya).
• Gunakan ToUpperInvariantdaripada ToLowerInvariantsaat menormalisasi string untuk perbandingan.

Larangan

• Gunakan kelebihan beban untuk operasi string yang tidak secara eksplisit atau implisit menentukan mekanisme perbandingan string.
• Gunakan operasi StringComparison.InvariantCulturestring berbasis-
  dalam banyak kasus; salah satu dari sedikit pengecualian adalah data yang secara
  linguistik bermakna tetapi agnostik secara budaya.

Berdasarkan aturan ini, Anda harus menggunakan:

string title = "STRING";
if (title.IndexOf("string", 0, StringComparison.[YourDecision]) != -1)
{
    // The string exists in the original
}

sedangkan [YourDecision] tergantung pada rekomendasi dari atas.

tautan sumber: http://msdn.microsoft.com/en-us/library/ms973919.aspx

Ini adalah solusi termudah.

1. Menurut Indeks

   string title = "STRING";
   
   if (title.IndexOf("string", 0, StringComparison.CurrentCultureIgnoreCase) != -1)
   {
       // contains 
   }

2. Dengan Mengubah kasing

   string title = "STRING";
   
   bool contains = title.ToLower().Contains("string")

3. Oleh Regex

   Regex.IsMatch(title, "string", RegexOptions.IgnoreCase);

Saya tahu bahwa ini bukan C #, tetapi dalam kerangka kerja (VB.NET) sudah ada fungsi seperti itu

Dim str As String = "UPPERlower"
Dim b As Boolean = InStr(str, "UpperLower")

Varian C #:

string myString = "Hello World";
bool contains = Microsoft.VisualBasic.Strings.InStr(myString, "world");

The InStrMetode dari VisualBasic perakitan adalah yang terbaik jika Anda memiliki kekhawatiran tentang internasionalisasi (atau Anda bisa reimplement itu). Melihat di dalamnya dotNeetPeek menunjukkan bahwa itu tidak hanya memperhitungkan huruf besar dan kecil, tetapi juga untuk jenis kana dan karakter setengah-lebar-penuh (sebagian besar relevan untuk bahasa Asia, meskipun ada versi lebar-lebar dari alfabet Romawi juga ). Saya melewatkan beberapa detail, tetapi periksa metode pribadi InternalInStrText:

private static int InternalInStrText(int lStartPos, string sSrc, string sFind)
{
  int num = sSrc == null ? 0 : sSrc.Length;
  if (lStartPos > num || num == 0)
    return -1;
  if (sFind == null || sFind.Length == 0)
    return lStartPos;
  else
    return Utils.GetCultureInfo().CompareInfo.IndexOf(sSrc, sFind, lStartPos, CompareOptions.IgnoreCase | CompareOptions.IgnoreKanaType | CompareOptions.IgnoreWidth);
}

Seperti ini:

string s="AbcdEf";
if(s.ToLower().Contains("def"))
{
    Console.WriteLine("yes");
}

Gunakan ini:

string.Compare("string", "STRING", new System.Globalization.CultureInfo("en-US"), System.Globalization.CompareOptions.IgnoreCase);

Ini sangat mirip dengan contoh lain di sini, tetapi saya telah memutuskan untuk menyederhanakan enum menjadi bool, primer karena alternatif lain biasanya tidak diperlukan. Ini contoh saya:

public static class StringExtensions
{
    public static bool Contains(this string source, string toCheck, bool bCaseInsensitive )
    {
        return source.IndexOf(toCheck, bCaseInsensitive ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal) >= 0;
    }
}

Dan penggunaannya adalah seperti:

if( "main String substring".Contains("SUBSTRING", true) )
....

Menggunakan RegEx adalah cara langsung untuk melakukan ini:

Regex.IsMatch(title, "string", RegexOptions.IgnoreCase);

Hanya untuk membangun jawaban di sini, Anda dapat membuat metode ekstensi string untuk membuatnya sedikit lebih ramah pengguna:

    public static bool ContainsIgnoreCase(this string paragraph, string word)
    {
        return CultureInfo.CurrentCulture.CompareInfo.IndexOf(paragraph, word, CompareOptions.IgnoreCase) >= 0;
    }

jika Anda ingin memeriksa apakah string yang Anda kirimkan dalam string maka ada metode sederhana untuk itu.

string yourStringForCheck= "abc";
string stringInWhichWeCheck= "Test abc abc";

bool isContained = stringInWhichWeCheck.ToLower().IndexOf(yourStringForCheck.ToLower()) > -1;

Nilai boolean ini akan kembali jika string berisi atau tidak

Sederhana dan berfungsi

title.ToLower().Contains("String".ToLower())

if ("strcmpstring1".IndexOf(Convert.ToString("strcmpstring2"), StringComparison.CurrentCultureIgnoreCase) >= 0){return true;}else{return false;}

Anda dapat menggunakan string.indexof ()fungsi. Ini akan menjadi case-sensitive

Kuncinya di sini adalah untuk mencari string, mengabaikan case, tetapi untuk tetap persis sama (dengan case yang sama).

 var s="Factory Reset";
 var txt="reset";
 int first = s.IndexOf(txt, StringComparison.InvariantCultureIgnoreCase) + txt.Length;
 var subString = s.Substring(first - txt.Length, txt.Length);

Output adalah "Reset"

public static class StringExtension
{
    #region Public Methods

    public static bool ExContains(this string fullText, string value)
    {
        return ExIndexOf(fullText, value) > -1;
    }

    public static bool ExEquals(this string text, string textToCompare)
    {
        return text.Equals(textToCompare, StringComparison.OrdinalIgnoreCase);
    }

    public static bool ExHasAllEquals(this string text, params string[] textArgs)
    {
        for (int index = 0; index < textArgs.Length; index++)
            if (ExEquals(text, textArgs[index]) == false) return false;
        return true;
    }

    public static bool ExHasEquals(this string text, params string[] textArgs)
    {
        for (int index = 0; index < textArgs.Length; index++)
            if (ExEquals(text, textArgs[index])) return true;
        return false;
    }

    public static bool ExHasNoEquals(this string text, params string[] textArgs)
    {
        return ExHasEquals(text, textArgs) == false;
    }

    public static bool ExHasNotAllEquals(this string text, params string[] textArgs)
    {
        for (int index = 0; index < textArgs.Length; index++)
            if (ExEquals(text, textArgs[index])) return false;
        return true;
    }

    /// <summary>
    /// Reports the zero-based index of the first occurrence of the specified string
    /// in the current System.String object using StringComparison.InvariantCultureIgnoreCase.
    /// A parameter specifies the type of search to use for the specified string.
    /// </summary>
    /// <param name="fullText">
    /// The string to search inside.
    /// </param>
    /// <param name="value">
    /// The string to seek.
    /// </param>
    /// <returns>
    /// The index position of the value parameter if that string is found, or -1 if it
    /// is not. If value is System.String.Empty, the return value is 0.
    /// </returns>
    /// <exception cref="ArgumentNullException">
    /// fullText or value is null.
    /// </exception>
    public static int ExIndexOf(this string fullText, string value)
    {
        return fullText.IndexOf(value, StringComparison.OrdinalIgnoreCase);
    }

    public static bool ExNotEquals(this string text, string textToCompare)
    {
        return ExEquals(text, textToCompare) == false;
    }

    #endregion Public Methods
}

Cara sederhana untuk pemula:

title.ToLower().Contains("string");//of course "string" is lowercase.