Bez względu na wielkość liter „Contains (string)”

Czy istnieje sposób, aby następujący zwrot był prawdziwy?

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

Wydaje się, że nie ma przeciążenia, które pozwala mi ustawić rozróżnianie wielkości liter. Obecnie UPPERCASE je oba, ale to po prostu głupie (przez co odnoszę się do problemów i18n , które są związane z obudową w górę iw dół).

AKTUALIZACJA
To pytanie jest starożytne i od tego czasu zdałem sobie sprawę, że poprosiłem o prostą odpowiedź na naprawdę obszerny i trudny temat, jeśli chcesz w pełni go zbadać.
W większości przypadków, w mono-językowej, bazy kod English to odpowiedź wystarczy. Podejrzewam, ponieważ większość osób przyjeżdżających tutaj należy do tej kategorii, jest to najpopularniejsza odpowiedź.
Ta odpowiedź rodzi jednak nieodłączny problem polegający na tym, że nie możemy porównać tekstu bez rozróżniania wielkości liter, dopóki nie dowiemy się, że oba teksty są tą samą kulturą i nie wiemy, czym jest ta kultura. To może być mniej popularna odpowiedź, ale myślę, że jest bardziej poprawna i dlatego oznaczyłem ją jako taką.

Aby sprawdzić, czy ciąg paragraphzawiera ciąg word(dzięki @QuarterMeister)

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

Gdzie culturejest przykład CultureInfoopisu języka, w którym napisany jest tekst.

To rozwiązanie jest przejrzyste w odniesieniu do definicji rozróżniania wielkości liter, która zależy od języka . Na przykład w języku angielskim używane są znaki Ioraz iw wersjach wielkiej i małej dziewiątej litery, natomiast w języku tureckim te znaki są stosowane w jedenastej i dwunastej litery 29-literowego alfabetu. Turecka wielka wersja „i” to nieznany znak „İ”.

Stąd ciągi znaków tini TINto samo słowo po angielsku , ale różne słowa po turecku . Jak rozumiem, jedno oznacza „duch”, a drugie to słowo onomatopei. (Turcy, poprawcie mnie, jeśli się mylę, lub sugerujcie lepszy przykład)

Podsumowując, możesz odpowiedzieć tylko na pytanie „czy te dwa ciągi są takie same, ale w różnych przypadkach”, jeśli wiesz, w jakim języku jest ten tekst . Jeśli nie wiesz, musisz wziąć łódkę. Biorąc pod uwagę hegemonię oprogramowania w języku angielskim, prawdopodobnie powinieneś uciekać się CultureInfo.InvariantCulture, ponieważ będzie to źle znane.

Możesz użyć metody String.IndexOf i podać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 ciągu:

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

Uwaga: propagacja zerowa ?. jest dostępna od wersji C # 6.0 (VS 2015) w przypadku starszych wersji

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

STOSOWANIE:

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

Możesz użyć w IndexOf()ten 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 względem -1.

MSDN

Liczona od zera pozycja indeksu wartości, jeśli ten ciąg zostanie znaleziony, lub -1, jeśli nie jest. Jeśli wartością jest String.Empty, zwracana jest wartość 0.

Alternatywne rozwiązanie przy użyciu Regex:

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

Zawsze możesz najpierw po prostu zwiększyć lub zmniejszyć ciągi znaków.

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

Ups, właśnie widziałem ten ostatni kawałek. Porównywanie bez rozróżniania wielkości liter *prawdopodobnie *i tak zrobiłoby to samo, a jeśli wydajność nie stanowi problemu, nie widzę problemu z tworzeniem dużych liter i porównywaniem ich. Mógłbym przysiąc, że raz widziałem porównanie bez rozróżniania wielkości liter ...

Tylko .NET Core 2.0+ (od teraz)

.NET Core ma kilka metod radzenia sobie z tym od wersji 2.0:

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

Przykład:

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

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

Jednym z problemów z odpowiedzią jest to, że zgłasza wyjątek, jeśli ciąg znaków ma wartość NULL. Możesz dodać to jako czek, aby nie:

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 krokiem naprzód, połączyłem kilka powyższych postów, 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)

OrdinalIgnoreCase, CurrentCultureIgnoreCase czy InvariantCultureIgnoreCase?

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

Dos

• Użyj StringComparison.OrdinalIgnoreCasedo porównań jako bezpiecznego domyślnego dopasowania łańcucha bez względu na kulturę.
• Użyj StringComparison.OrdinalIgnoreCaseporównań dla zwiększenia prędkości.
• Użyj StringComparison.CurrentCulture-basedoperacji na łańcuchach podczas wyświetlania danych wyjściowych użytkownikowi.
• Przełącz bieżące użycie operacji na łańcuchach opartych na niezmiennej kulturze, aby zastosować niejęzykowe StringComparison.Ordinallub StringComparison.OrdinalIgnoreCasegdy porównanie jest
  nieistotne językowo (na przykład symboliczne).
• Użyj ToUpperInvariantraczej niż ToLowerInvariantpodczas normalizacji ciągów w celu porównania.

Nie

• Przeciążeń należy używać do operacji na łańcuchach, które nie określają jawnie ani niejawnie mechanizmu porównywania łańcuchów.
• W większości przypadków używaj operacji StringComparison.InvariantCulturełańcuchowych opartych na łańcuchach
  ; jednym z nielicznych wyjątków byłyby
  utrwalone pod względem językowym, ale kulturowo agnostyczne dane.

W oparciu o te zasady powinieneś używać:

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

mając na uwadze, że [TwojaDecyzja] zależy od powyższych zaleceń.

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

To są najprostsze rozwiązania.

1. Według indeksu

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

2. Zmieniając obudowę

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

3. Według Regex

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

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

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

Wariant C #:

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

InStrMetoda z VisualBasic montaż jest najlepszy, jeśli masz obawy dotyczące internacjonalizacji (lub można go reimplement). Patrząc w nim dotNeetPeek pokazuje, że uwzględnia nie tylko wielkie i małe litery, ale także typ kana i znaki o pełnej szerokości i połowie szerokości (dotyczy to głównie języków azjatyckich, chociaż istnieją również wersje alfabetu rzymskiego o pełnej szerokości) ). Pomijam niektóre szczegóły, 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);
}

Takie jak to:

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

Użyj tego:

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

Jest to dość podobne do innego przykładu tutaj, ale zdecydowałem się uprościć wyliczanie bool, pierwotne, 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 jest coś takiego:

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

Korzystanie z RegEx jest prostym sposobem na to:

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

Aby skorzystać z odpowiedzi tutaj, możesz utworzyć metodę rozszerzenia ciągu znaków, aby uczynić ją nieco bardziej przyjazną dla użytkownika:

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

jeśli chcesz sprawdzić, czy przekazany ciąg jest ciągiem, istnieje prosta metoda.

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

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

Ta wartość logiczna zostanie zwrócona, jeśli ciąg znaków jest zawarty, czy nie

Tak proste i działa

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

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

Możesz użyć string.indexof ()funkcji. Będzie to bez rozróżniania wielkości liter

Sztuczka polega na tym, aby wyszukać ciąg znaków, ignorując wielkość liter, ale zachować dokładnie to samo (z tą samą 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”

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
}

Prosty sposób dla początkujących:

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