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

2907

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.

Boris Callens
quelle

Antworten:

1398

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.

Oberst Panik
quelle
67
Warum nicht culture.CompareInfo.IndexOf(paragraph, word, CompareOptions.IgnoreCase) >= 0? Dies verwendet die richtige Kultur und unterscheidet nicht zwischen Groß- und Kleinschreibung, weist keine temporären Kleinbuchstaben zu und vermeidet die Frage, ob das Konvertieren in Kleinbuchstaben und das Vergleichen immer mit einem Vergleich ohne Berücksichtigung von Groß- und Kleinschreibung identisch sind.
Quartiermeister
9
Diese Lösung verschmutzt auch unnötig den Heap, indem sie Speicher für eine
Suchfunktion zuweist
15
Ein Vergleich mit ToLower () führt zu unterschiedlichen Ergebnissen bei einem IndexOf ohne Berücksichtigung der Groß- und Kleinschreibung, wenn zwei verschiedene Buchstaben denselben Kleinbuchstaben haben. Wenn Sie beispielsweise ToLower () für U + 0398 "Griechischer Großbuchstabe Theta" oder U + 03F4 "Griechischer Großbuchstabe Theta" aufrufen, erhalten Sie U + 03B8, "Griechischer Kleinbuchstabe Theta", aber die Großbuchstaben werden als unterschiedlich angesehen. Bei beiden Lösungen werden Kleinbuchstaben mit demselben Großbuchstaben unterschiedlich betrachtet, z. B. U + 0073 "Latin Small Letter S" und U + 017F "Latin Small Letter Long S", sodass die IndexOf-Lösung konsistenter erscheint.
Quartiermeister
3
@Quartermeister - und übrigens, ich glaube, .NET 2 und .NET4 verhalten sich dabei unterschiedlich, da .NET 4 immer NORM_LINGUISTIC_CASING verwendet, während .NET 2 dies nicht tat (diese Flags sind unter Windows Vista aufgetreten).
Simon Mourier
10
Warum haben Sie nicht "ddddfg" .IndexOf ("Df", StringComparison.OrdinalIgnoreCase) geschrieben?
Chen
2713

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);
JaredPar
quelle
3
Tolle String-Erweiterungsmethode! Ich habe meine bearbeitet, um zu überprüfen, ob die Quellzeichenfolge nicht null ist, um zu verhindern, dass bei der Ausführung von .IndexOf () Objektreferenzfehler auftreten.
Richard Pursehouse
8
Dies gibt die gleiche Antwort wie paragraph.ToLower(culture).Contains(word.ToLower(culture))bei CultureInfo.InvariantCultureund löst keine Lokalisierungsprobleme. Warum überkomplizieren? stackoverflow.com/a/15464440/284795
Colonel Panic
60
@ColonelPanic Die ToLowerVersion enthält 2 Zuordnungen, die bei einem Vergleichs- / Suchvorgang nicht erforderlich sind. Warum in einem Szenario, das es nicht erfordert, unnötig zuordnen?
JaredPar
4
@ Seeabiscuit, das nicht funktioniert, weil stringes ein ist, IEnumerable<char>daher können Sie es nicht verwenden, um
Teilzeichenfolgen
6
Ein Wort der Warnung: Standardmäßig string.IndexOf(string)wird die aktuelle Kultur verwendet, während standardmäßig string.Contains(string)der Ordnungsvergleich verwendet wird. Wie wir wissen, kann Ersteres geändert werden, indem eine längere Überlastung ausgewählt wird, während Letzteres nicht geändert werden kann. Eine Folge dieser Inkonsistenz ist das folgende Codebeispiel:Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture; string self = "Waldstrasse"; string value = "straße"; Console.WriteLine(self.Contains(value));/* False */ Console.WriteLine(self.IndexOf(value) >= 0);/* True */
Jeppe Stig Nielsen
231

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.

mkchandler
quelle
148

Alternative Lösung mit Regex:

bool contains = Regex.IsMatch("StRiNG to search", Regex.Escape("string"), RegexOptions.IgnoreCase);
Jed
quelle
6
Gute Idee, auch wir haben viele bitweise Kombinationen in RegexOptions wie RegexOptions.IgnoreCase & RegexOptions.IgnorePatternWhitespace & RegexOptions.CultureInvariant;für jeden, der hilft.
Saravanan
7
Ich muss sagen, ich bevorzuge diese Methode, obwohl ich IsMatch aus Gründen der Übersichtlichkeit verwende.
Wonea
31
Was noch schlimmer ist: Da die Suchzeichenfolge als regulärer Ausdruck interpretiert wird, führen einige Satzzeichen zu falschen Ergebnissen (oder lösen aufgrund eines ungültigen Ausdrucks eine Ausnahme aus). Versuchen Sie, nach "."in zu suchen "This is a sample string that doesn't contain the search string". Oder versuchen Sie es zu suchen "(invalid".
CHao
17
@cHao: In diesem Fall Regex.Escapekönnte helfen. Regex scheint immer noch unnötig zu sein, wenn IndexOf/ extension Containseinfach (und wohl klarer) ist.
Dan Mangiarelli
6
Beachten Sie, dass ich nicht angedeutet habe, dass diese Regex-Lösung der beste Weg ist. Ich habe einfach die Liste der Antworten auf die ursprünglich gestellte Frage "Gibt es eine Möglichkeit, die folgende Rückgabe wahr zu machen?" Hinzugefügt.
Jed
79

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 ...

Ed S.
quelle
122
Suche nach "Türkei Test" :)
Jon Skeet
7
In einigen französischen Gebietsschemas haben Großbuchstaben keine diakritischen Zeichen, daher ist ToUpper () möglicherweise nicht besser als ToLower (). Ich würde sagen, verwenden Sie die richtigen Tools, wenn sie verfügbar sind - vergleichen Sie die Groß- und Kleinschreibung nicht.
Blair Conrad
5
Verwenden Sie nicht ToUpper oder ToLower und tun Sie, was Jon Skeet gesagt hat
Peter Gfader
14
Ich habe das nach zwei Jahren und einem neuen Downvote wieder gesehen ... trotzdem stimme ich zu, dass es bessere Möglichkeiten gibt, Strings zu vergleichen. Es werden jedoch nicht alle Programme lokalisiert (die meisten nicht) und viele sind interne oder Wegwerf-Apps. Da ich kaum Anerkennung für Ratschläge erwarten kann, die am besten für Wegwerf-Apps übrig sind ... Ich gehe weiter: D
Ed S.
8
Ist die Suche nach "Türkei-Test" dasselbe wie die Suche nach "TÜRKEI-TEST"?
JackAce
55

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.

Mathieu Renda
quelle
1
Jetzt auch verfügbar in .NET Standard 2.1
Paweł Bulwan
52

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;
} 
FeiBao 飞 豹
quelle
8
Wenn toCheck die leere Zeichenfolge ist, muss gemäß der Contains-Dokumentation true zurückgegeben werden: "true, wenn der value-Parameter in dieser Zeichenfolge vorkommt, oder wenn value die leere Zeichenfolge ist (" "); andernfalls false."
Amurra
3
Muss der vorgeschlagene Code aufgrund des obigen Kommentars von amurra nicht korrigiert werden? Und sollte dies nicht zur akzeptierten Antwort hinzugefügt werden, damit die beste Antwort zuerst kommt?
David White
13
Dies gibt nun true zurück, wenn source eine leere Zeichenfolge oder null ist, unabhängig davon, was toCheck ist. Das kann nicht richtig sein. Auch IndexOf gibt bereits true zurück, wenn toCheck eine leere Zeichenfolge ist und die Quelle nicht null ist. Was hier benötigt wird, ist eine Prüfung auf Null. Ich schlage vor, wenn (source == null || value == null) false zurückgibt;
Colin
2
Die Quelle kann nicht null sein
Lucas
1
if (string.IsNullOrEmpty(source)) return string.IsNullOrEmpty(toCheck);
Kyle Delaney
35

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;
    }
}
Andrew
quelle
Warum lässt du eine andere Abstraktionsebene zu StringComparison?
l - '' '' '
35

Das ist sauber und einfach.

Regex.IsMatch(file, fileNamestr, RegexOptions.IgnoreCase)
Takirala
quelle
31
Dies stimmt jedoch mit einem Muster überein. In Ihrem Beispiel, wenn fileNamestrspezielle Regex Zeichen hat (zB *, +, ., etc.) , dann werden Sie in für eine ziemliche Überraschung sein. Die einzige Möglichkeit, diese Lösung wie eine ordnungsgemäße ContainsFunktion funktionieren zu lassen, besteht darin, fileNamestrdurch Ausführen zu entkommen Regex.Escape(fileNamestr).
XåpplI'-I0llwlg'I -
Außerdem ist das Parsen und Abgleichen eines
regulären Ausdrucks
29

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

Fabian Bigler
quelle
Was ist, wenn Sie wissen, dass Sie immer eine englische Zeichenfolge bekommen? welches soll man benutzen?
BKSpurgeon
1
@ BKSpurgeon Ich würde OrdinalIgnoreCase verwenden, wenn der Fall keine Rolle spielt
Fabian Bigler
20

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);
LAV VISHWAKARMA
quelle
11

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");
Serhio
quelle
11

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);
}
Casey
quelle
11

Genau wie dieser:

string s="AbcdEf";
if(s.ToLower().Contains("def"))
{
    Console.WriteLine("yes");
}
cdytoby
quelle
3
Dies ist nicht kulturspezifisch und kann in einigen Fällen fehlschlagen. Culture.CompareInfo.IndexOf (Absatz, Wort, CompareOptions.IgnoreCase) sollte verwendet werden.
Hikalkan
8

Benutze das:

string.Compare("string", "STRING", new System.Globalization.CultureInfo("en-US"), System.Globalization.CompareOptions.IgnoreCase);
mr.martan
quelle
26
Der Fragesteller sucht Containsnicht Compare.
DuckMaestro
@DuckMaestro, die akzeptierte Antwort ist die Umsetzung Containsmit IndexOf. Dieser Ansatz ist also ebenso hilfreich! Das C # -Codebeispiel auf dieser Seite verwendet string.Compare (). Die Wahl des SharePoint-Teams!
Vulkanischer Rabe
6

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) )
....
TarmoPikaro
quelle
6

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

Regex.IsMatch(title, "string", RegexOptions.IgnoreCase);
Stend
quelle
4
Ihre Antwort ist genau die gleiche wie die von guptat59, aber wie in seiner Antwort erwähnt, stimmt diese mit einem regulären Ausdruck überein. Wenn die zu testende Zeichenfolge spezielle Regex-Zeichen enthält, wird nicht das gewünschte Ergebnis erzielt.
Casey
2
Dies ist eine direkte Kopie dieser Antwort und leidet unter den gleichen Problemen wie in dieser Antwort angegeben
Liam
Einverstanden. Studieren Sie reguläre Ausdrücke
Jared
5

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;
    }
Melbourne Entwickler
quelle
1
Angenommen, Ihr Absatz und Ihr Wort sind immer in den USA
Boris Callens,
3
Verwenden Sie return CultureInfo.CurrentCulture.CompareInfo.IndexOf(paragraph, word, CompareOptions.IgnoreCase) >= 0;stattdessen, um Probleme beim Erzwingen der Kultur in die USA zu vermeiden .
AndrewWhalan
3

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

shaishav shukla
quelle
3

So einfach und funktioniert

title.ToLower().Contains("String".ToLower())
Pradeep Asanka
quelle
2
if ("strcmpstring1".IndexOf(Convert.ToString("strcmpstring2"), StringComparison.CurrentCultureIgnoreCase) >= 0){return true;}else{return false;}
Tamilselvan K.
quelle
2

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

Okan SARICA
quelle
2

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"

Mr.B.
quelle
-1
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
}
Final Heaven
quelle
-4

Einfacher Weg für Anfänger:

title.ToLower().Contains("string");//of course "string" is lowercase.
O Thạnh Ldt
quelle
Downvote für einfach falsch. Was ist, wenn title = StRiNg? StRiNg! = String und StRiNg! = STRING
Berniefitz
Ich lag falsch. Bearbeiten Sie die Antwort wie folgt, zu einfach, einfach: <br/> title.ToLower (). Enthält ("string") // natürlich ist "string" in Kleinbuchstaben
O Thạnh Ldt