Groß- und Kleinschreibung nicht berücksichtigen 'Enthält (Zeichenfolge)'

Gibt es eine Möglichkeit, die folgende Rückgabe wahr zu machen?

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

Es scheint keine Überlastung zu geben, die es mir ermöglicht, die Groß- und Kleinschreibung zu ändern. Derzeit überschreibe ich beide, aber das ist nur albern (womit ich mich auf die i18n- Probleme beziehe, die mit dem Auf- und Ab-Gehäuse einhergehen).

UPDATE
Diese Frage ist uralt und seitdem habe ich festgestellt, dass ich nach einer einfachen Antwort für ein wirklich umfangreiches und schwieriges Thema gefragt habe, wenn Sie es vollständig untersuchen möchten.
In den meisten Fällen reicht diese Antwort in einsprachigen englischen Codebasen aus. Ich vermute, weil die meisten Leute, die hierher kommen, in diese Kategorie fallen, ist dies die beliebteste Antwort.
Diese Antwort wirft jedoch das inhärente Problem auf, dass wir Text ohne Berücksichtigung der Groß- und Kleinschreibung nicht vergleichen können, bis wir wissen, dass beide Texte dieselbe Kultur sind und wir wissen, was diese Kultur ist. Dies ist vielleicht eine weniger beliebte Antwort, aber ich denke, sie ist korrekter und deshalb habe ich sie als solche markiert.

Um zu testen, ob die Zeichenfolge die Zeichenfolge paragraphenthält word(danke @QuarterMeister)

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

Wo culturewird die CultureInfoSprache beschrieben, in der der Text geschrieben ist?

Diese Lösung ist transparent über die Definition der Groß- und Kleinschreibung, die sprachabhängig ist . Beispielsweise verwendet die englische Sprache die Zeichen Isowie idie Groß- und Kleinbuchstaben des neunten Buchstabens, während die türkische Sprache diese Zeichen für den elften und zwölften Buchstaben ihres 29 Buchstaben langen Alphabets verwendet. Die türkische Großbuchstabenversion von 'i' ist das unbekannte Zeichen 'İ'.

Somit sind die Zeichenfolgen tinund TINdas gleiche Wort auf Englisch , aber verschiedene Wörter auf Türkisch . Soweit ich weiß, bedeutet einer "Geist" und der andere ist ein Onomatopoeia-Wort. (Türken, bitte korrigieren Sie mich, wenn ich falsch liege, oder schlagen Sie ein besseres Beispiel vor)

Zusammenfassend lässt sich sagen , dass Sie die Frage " Sind diese beiden Zeichenfolgen gleich, aber in unterschiedlichen Fällen" nur beantworten können, wenn Sie wissen, in welcher Sprache der Text verfasst ist . Wenn Sie es nicht wissen, müssen Sie einen Kahn nehmen. Angesichts der Hegemonie von Englisch in der Software sollten Sie wahrscheinlich darauf zurückgreifen CultureInfo.InvariantCulture, da dies auf bekannte Weise falsch sein wird.

Sie können die String.IndexOf-Methode verwenden und StringComparison.OrdinalIgnoreCaseals zu verwendenden Suchtyp übergeben :

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

Noch besser ist es, eine neue Erweiterungsmethode für Zeichenfolgen zu definieren:

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

Beachten Sie, dass die Nullweitergabe ?. seit C # 6.0 (VS 2015) für ältere Versionen verfügbar ist

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

VERWENDUNGSZWECK:

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

Sie können IndexOf()wie folgt verwenden:

string title = "STRING";

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

Da 0 (Null) ein Index sein kann, prüfen Sie gegen -1.

MSDN

Die auf Null basierende Indexposition des Werts, wenn diese Zeichenfolge gefunden wird, oder -1, wenn dies nicht der Fall ist. Wenn der Wert String.Empty ist, ist der Rückgabewert 0.

Alternative Lösung mit Regex:

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

Sie können die Zeichenfolgen immer zuerst nach oben oder unten verschieben.

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

Hoppla, habe gerade das letzte bisschen gesehen. Ein Vergleich ohne Berücksichtigung der Groß- und Kleinschreibung würde *wahrscheinlich *sowieso dasselbe tun, und wenn die Leistung kein Problem darstellt, sehe ich kein Problem beim Erstellen und Vergleichen von Großbuchstaben. Ich hätte schwören können, dass ich einmal einen Vergleich ohne Berücksichtigung der Groß- und Kleinschreibung gesehen habe ...

Nur .NET Core 2.0+ (ab sofort)

.NET Core verfügt seit Version 2.0 über zwei Methoden, um damit umzugehen:

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

Beispiel:

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

Mit der Zeit werden sie wahrscheinlich den Weg in den .NET-Standard und von dort in alle anderen Implementierungen der Basisklassenbibliothek finden.

Ein Problem mit der Antwort ist, dass eine Ausnahme ausgelöst wird, wenn eine Zeichenfolge null ist. Sie können das als Scheck hinzufügen, damit es nicht:

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

Die StringExtension-Klasse ist der Weg nach vorne. Ich habe einige der obigen Beiträge kombiniert, um ein vollständiges Codebeispiel zu erhalten:

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

Das ist sauber und einfach.

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

OrdinalIgnoreCase, CurrentCultureIgnoreCase oder InvariantCultureIgnoreCase?

Da dies fehlt, finden Sie hier einige Empfehlungen, wann Sie welche verwenden sollten:

DOS

• Verwenden Sie diese Option StringComparison.OrdinalIgnoreCasefür Vergleiche als sichere Standardeinstellung für den kulturunabhängigen String-Abgleich.
• Verwenden Sie StringComparison.OrdinalIgnoreCaseVergleiche für eine höhere Geschwindigkeit.
• Verwenden Sie StringComparison.CurrentCulture-basedZeichenfolgenoperationen, wenn Sie dem Benutzer die Ausgabe anzeigen.
• Schalten Sie die aktuelle Verwendung von Zeichenfolgenoperationen basierend auf der invarianten Kultur auf die Verwendung der nichtsprachlichen StringComparison.Ordinaloder StringComparison.OrdinalIgnoreCasewenn der Vergleich
  sprachlich irrelevant ist (z. B. symbolisch).
• Verwenden Sie ToUpperInvariantstatt , ToLowerInvariantwenn Normalisierungs Saiten zum Vergleich.

Nicht

• Verwenden Sie Überladungen für Zeichenfolgenoperationen, die den Zeichenfolgenvergleichsmechanismus nicht explizit oder implizit angeben.
• Verwenden Sie in den meisten Fällen auf StringComparison.InvariantCultureZeichenfolgen basierende Zeichenfolgenoperationen
  . Eine der wenigen Ausnahmen wäre das
  Fortbestehen sprachlich bedeutsamer, aber kulturell agnostischer Daten.

Basierend auf diesen Regeln sollten Sie Folgendes verwenden:

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

[YourDecision] hängt von den Empfehlungen von oben ab.

Link zur Quelle: http://msdn.microsoft.com/en-us/library/ms973919.aspx

Dies sind die einfachsten Lösungen.

1. Nach Index von

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

2. Durch Ändern des Falls

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

3. Von Regex

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

Ich weiß, dass dies nicht das C # ist, aber im Framework (VB.NET) gibt es bereits eine solche Funktion

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

C # -Variante:

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

Die InStrMethode aus der VisualBasic-Assembly ist die beste, wenn Sie Bedenken hinsichtlich der Internationalisierung haben (oder diese erneut implementieren könnten). Ein Blick darauf zeigt, dass dotNeetPeek nicht nur Großbuchstaben und Kleinbuchstaben berücksichtigt, sondern auch Zeichen vom Typ Kana und Zeichen voller oder halber Breite (meistens relevant für asiatische Sprachen, obwohl es auch Versionen des römischen Alphabets in voller Breite gibt ). Ich überspringe einige Details, aber schau dir die private Methode an 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);
}

Genau wie dieser:

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

Benutze das:

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

Dies ist einem anderen Beispiel hier ziemlich ähnlich, aber ich habe beschlossen, die Aufzählung auf bool zu vereinfachen, primär, da andere Alternativen normalerweise nicht benötigt werden. Hier ist mein Beispiel:

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

Und Nutzung ist so etwas wie:

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

Die Verwendung eines RegEx ist ein einfacher Weg, um dies zu tun:

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

Um auf der Antwort hier aufzubauen, können Sie eine String-Erweiterungsmethode erstellen, um dies ein wenig benutzerfreundlicher zu gestalten:

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

Wenn Sie überprüfen möchten, ob sich Ihre übergebene Zeichenfolge in einer Zeichenfolge befindet, gibt es dafür eine einfache Methode.

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

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

Dieser boolesche Wert wird zurückgegeben, wenn die Zeichenfolge enthalten ist oder nicht

So einfach und funktioniert

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

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

Sie können die string.indexof ()Funktion verwenden. Dies unterscheidet nicht zwischen Groß- und Kleinschreibung

Der Trick hier besteht darin, nach der Zeichenfolge zu suchen und die Groß- und Kleinschreibung zu ignorieren, sie jedoch genau gleich zu halten (mit der gleichen Groß- / Kleinschreibung).

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

Ausgang ist "Zurücksetzen"

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
}

Einfacher Weg für Anfänger:

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