Wielkość liter jest niewrażliwa "Contains(string)"

Możesz użyć String.IndexOf Method and pass StringComparison.OrdinalIgnoreCase jako typ wyszukiwania do użycia:

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

Jeszcze lepsze jest zdefiniowanie nowej metody rozszerzenia dla ciągu znaków:

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

Zauważ, że propagacja zerowa ?. jest dostępny od C # 6.0 (VS 2015), dla starszych wersji używać

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

Użycie:

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

Możesz użyć IndexOf() w następujący sposób:

string title = "STRING";

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

Ponieważ 0 (zero) może być indeksem, sprawdzasz przed -1.

MSDN

Pozycja indeksowana od zera wartości, jeśli ten łańcuch zostanie znaleziony, lub -1 jeśli nie. If value is String.Empty, zwracana wartość to 0.

Alternatywne rozwiązanie przy użyciu Regex:

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

Zawsze można po prostu up lub downcase struny pierwszy.

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

. NET Core 2.0 + only (od teraz)

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

Przykład:

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

Z czasem prawdopodobnie trafią do standardu. NET, a stamtąd do wszystkich innych implementacji biblioteki klas bazowych.

Problem z odpowiedzią polega na tym, że wyrzuci wyjątek, jeśli łańcuch jest null. Możesz to dodać jako czek więc nie będzie:

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;
} 

Klasa StringExtension jest drogą naprzód, połączyłem kilka postów powyżej, aby dać pełny przykład kodu:

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;
    }
}

To jest czyste i proste.

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

Zwykła, aktualna czy niezmienna?

Ponieważ tego brakuje, oto kilka zaleceń, kiedy użyć którego:

Dos

• użyj StringComparison.OrdinalIgnoreCase do porównań jako Bezpieczne domyślne dopasowanie ciągów kulturowo-agnostycznych.
• użyj StringComparison.OrdinalIgnoreCase porównania dla zwiększenia prędkości.
• Use StringComparison.CurrentCulture-based string operations podczas wyświetlania danych wyjściowych użytkownikowi.
• Switch current use of string operations na podstawie niezmiennika kultury, aby używać nie-lingwistycznych StringComparison.Ordinal lub StringComparison.OrdinalIgnoreCase, gdy porównanie jest
  bez znaczenia językowego (np. symbolicznego).
• użyj ToUpperInvariant zamiast ToLowerInvariant, gdy normalizacja ciągów do porównania.

Don ' ts

• użyj przeciążeń dla operacji ciągów znaków, które nie są jawnie lub pośrednio określa mechanizm porównywania łańcuchów.
• Use StringComparison.InvariantCulture -based string
  operacje w większości przypadków; jednym z nielicznych wyjątków byłoby be
  utrzymujące się dane lingwistyczne, ale kulturowo-agnostyczne.

Na podstawie tych zasad należy użyć:

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

Podczas Gdy [twoja decyzja] zależy od zaleceń z góry.

Link źródła: http://msdn.microsoft.com/en-us/library/ms973919.aspx

Są to najprostsze rozwiązania.

1. Według indeksu

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

2. Zmieniając wielkość liter

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

3. By Regex

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

Jak proste i działa

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

Tak po prostu:

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

Wiem, że to nie jest C#, ale w frameworku (VB.NET) istnieje już taka funkcja

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

C# variant:

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

Metoda InStr z zestawu VisualBasic jest najlepsza, jeśli masz obawy o internacjonalizację (lub możesz ją ponownie zaimplementować). Patrząc w nim dotNeetPeek pokazuje, że nie tylko uwzględnia wielkie i małe litery, ale także znaki typu kana i znaki o pełnej lub pół szerokości (głównie istotne dla języków azjatyckich, chociaż istnieją również wersje alfabetu Rzymskiego o pełnej szerokości). Pomijam kilka szczegółów, ale sprawdź metodę prywatną 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);
}

Użyj tego:

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

Jest to dość podobne do innych przykładów tutaj, ale zdecydowałem się uprościć enum do bool, primary, ponieważ inne alternatywy zwykle nie są potrzebne. Oto mój przykład:

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;
    }
}

A użycie to coś w stylu:

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

Użycie RegEx jest prostą drogą do tego:

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

Aby zbudować odpowiedź tutaj, możesz utworzyć metodę rozszerzenia łańcucha znaków, aby uczynić ją bardziej przyjazną dla użytkownika:

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

Możesz użyć parametru porównywania łańcuchów (dostępnego w. Net 2.1 i nowszych) String.Zawiera Metodę .

public bool Contains (string value, StringComparison comparisonType);

Przykład:

string title = "ASTRINGTOTEST";
title.Contains("string", StringComparison.InvariantCultureIgnoreCase);

Jeśli chcesz sprawdzić, czy przekazywany łańcuch jest w łańcuchu, to istnieje na to prosta metoda.

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

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

Ta wartość logiczna zwróci, jeśli łańcuch jest zawarty lub nie

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

Możesz użyć funkcji string.indexof (). To będzie niewrażliwe na wielkość liter

Sztuczka polega na szukaniu łańcucha, ignorując wielkość liter, ale zachowując go dokładnie tak samo (z tą samą wielkością liter).

 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);

Wyjście To "Reset"

Podobne do poprzednich odpowiedzi (używając metody rozszerzenia), ale z dwoma prostymi kontrolami null (C # 6.0 i wyżej):

public static bool ContainsIgnoreCase(this string source, string substring)
{
    return source?.IndexOf(substring ?? "", StringComparison.OrdinalIgnoreCase) >= 0;
}

Jeśli source to null, zwróć false (za pomocą operatora propagacji null ?.)

Jeśli substring jest null, traktuj jako pusty łańcuch i zwracaj true (za pomocą operatora null-coalescing??)

StringComparison można oczywiście wysłać jako parametr w razie potrzeby.

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
}

Bazując na istniejących odpowiedziach i na dokumentacji metody Contains polecam utworzenie następującego rozszerzenia, które zajmuje się również przypadkami narożnymi:

public static class VStringExtensions 
{
    public static bool Contains(this string source, string toCheck, StringComparison comp) 
    {
        if (toCheck == null) 
        {
            throw new ArgumentNullException(nameof(toCheck));
        }

        if (source.Equals(string.Empty)) 
        {
            return false;
        }

        if (toCheck.Equals(string.Empty)) 
        {
            return true;
        }

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

Prosty sposób dla początkujących:

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