it-swarm.com.de

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

Gibt es eine Möglichkeit, die folgenden Ergebnisse wahr zu machen?

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

Es scheint keine Überlastung zu geben, die es mir erlaubt, die Groß-/Kleinschreibung einzustellen. Momentan ÜBERHALTE ich beide, aber das ist einfach dumm (mit dem ich mich auf die i18n - Probleme beziehe, die mit Auf und Ab verbunden sind Gehäuse).

UPDATE
Diese Frage ist uralt, und seitdem ist mir klar, dass ich um eine einfache Antwort auf ein wirklich umfangreiches und schwieriges Thema gebeten habe, wenn Sie es gründlich untersuchen wollen.
In den meisten Fällen reicht die Antwort auf einsprachige englische Codebasis diese aus. Ich vermute, da 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 nicht zwischen Groß- und Kleinschreibung unterscheiden 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, es ist richtiger und deshalb habe ich sie als solche markiert.

2579
Boris Callens

Um zu testen, ob die Zeichenfolge paragraph die Zeichenfolge Word enthält (danke @QuarterMeister)

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

Dabei ist culture die Instanz von CultureInfo , die die Sprache beschreibt, in der der Text geschrieben ist.

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

Daher sind die Zeichenfolgen tin und TIN dasselbe Wort in Englisch, aber verschiedene Wörter in Türkisch. Wie ich es verstehe, bedeutet einer "Geist" und der andere ist ein Wort der Onomatopoie. (Türken, bitte korrigieren Sie mich, wenn ich falsch liege, oder schlagen Sie ein besseres Beispiel vor)

Zusammenfassend können Sie nur die Frage beantworten, 'sind diese beiden Zeichenfolgen gleich, aber in verschiedenen Fällen' wenn Sie wissen, in welcher Sprache der Text ist. Wenn Sie es nicht wissen, müssen Sie einen Kahn nehmen. In Anbetracht der englischen Hegemonie in Software sollten Sie wahrscheinlich auf CultureInfo.InvariantCulture zurückgreifen, da dies auf bekannte Weise falsch ist.

1202
Colonel Panic

Sie können die String.IndexOf-Methode verwenden und StringComparison.OrdinalIgnoreCase als Suchtyp verwenden:

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

Noch besser ist es, eine neue Erweiterungsmethode für string 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 null propagation?. 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);
2486
JaredPar

Sie können IndexOf() folgendermaßen 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 nullbasierte Indexposition des Werts, wenn diese Zeichenfolge gefunden wird, oder -1. wenn es das nicht ist. Wenn der Wert String.Empty ist, lautet der Rückgabewert 0.

212
mkchandler

Alternative Lösung mit Regex:

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

Sie können die Saiten immer zuerst auf- oder abwandern. 

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

Hoppla, ich habe gerade das letzte Stück gesehen. Bei Vergleichen ohne Berücksichtigung der Groß- und Kleinschreibung würde *wobably* sowieso dasselbe tun. Wenn Leistung kein Problem darstellt, sehe ich kein Problem, wenn Sie Kopien in Großbuchstaben erstellen und diese vergleichen. Ich hätte schwören können, dass ich einmal einen Vergleich zwischen Groß- und Kleinschreibung gesehen habe ...

70
Ed S.

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

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;
} 
48
FeiBao 飞豹

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

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

Das ist sauber und einfach.

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

OrdinalIgnoreCase, CurrentCultureIgnoreCase oder InvariantCultureIgnoreCase?

Da dies fehlt, hier einige Empfehlungen, wann welche verwendet werden sollte:

DOS

  • Verwenden Sie StringComparison.OrdinalIgnoreCase für Vergleiche als sichere Standardeinstellung für das Anpassen von Zeichenfolgen mit Kultur-Agnostik.
  • Verwenden Sie StringComparison.OrdinalIgnoreCase Vergleiche , Um die Geschwindigkeit zu erhöhen.
  • Verwenden Sie StringComparison.CurrentCulture-based-Zeichenfolgenoperationen , Wenn Sie dem Benutzer die Ausgabe anzeigen.
  • Wechseln Sie die aktuelle Verwendung von Zeichenfolgenoperationen basierend auf der invarianten Kultur , Um den nichtsprachlichen Code StringComparison.Ordinal oder StringComparison.OrdinalIgnoreCase zu verwenden, wenn der Vergleich erfolgt
    sprachlich irrelevant (zB symbolisch). 
  • Verwenden Sie ToUpperInvariant anstelle von ToLowerInvariant, wenn Zeichenketten zum Vergleich normalisiert werden.

Don'ts

  • Verwenden Sie Überladungen für Zeichenfolgenoperationen, die nicht ausdrücklich Angeben, oder implizieren den Zeichenfolgenvergleichsmechanismus.
  • Verwenden Sie eine StringComparison.InvariantCulture-basierte Zeichenfolge
    Operationen in den meisten Fällen; Eine der wenigen Ausnahmen wäre
    .__ persistente sprachlich bedeutsame, aber kulturell agnostische 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/de-de/library/ms973919.aspx

24
Fabian Bigler

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 in den .NET-Standard und von dort in alle anderen Implementierungen der Basisklassenbibliothek gelangen.

12
Mathieu Renda

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 von Groß- und Kleinschreibung

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

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

Genau wie dieser:

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

Die InStr-Methode aus der VisualBasic-Assembly ist am besten geeignet, wenn Sie Bedenken hinsichtlich der Internationalisierung haben (oder sie möglicherweise neu implementieren). DotNeetPeek zeigt darin, dass nicht nur Groß- und Kleinbuchstaben berücksichtigt werden, sondern auch Kana-Zeichen und Voll-/Halb-Zeichen (meistens für asiatische Sprachen relevant), obwohl auch das lateinische Alphabet in voller Breite verfügbar ist ). Ich überspringe einige Details, aber checke die private Methode 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);
}
10
Casey

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");
10
serhio

Benutze das:

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

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

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

Dies ist dem anderen Beispiel hier ziemlich ähnlich, aber ich habe mich entschlossen, die Aufzählung mit bool zu vereinfachen, hauptsächlich weil 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 Verwendung ist so etwas wie:

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

Der Trick hier besteht darin, nach der Zeichenfolge zu suchen und die Groß-/Kleinschreibung zu ignorieren, sie jedoch genau gleich zu halten (mit derselben 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);

Ausgabe ist "Reset"

2
Mr.B

Sie können die Funktion string.indexof () verwenden. Dies ist unabhängig von der Groß- und Kleinschreibung

2
Okan SARICA
if ("strcmpstring1".IndexOf(Convert.ToString("strcmpstring2"), StringComparison.CurrentCultureIgnoreCase) >= 0){return true;}else{return false;}
2
Tamilselvan K
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
}
0
Final Heaven

wenn Sie überprüfen möchten, ob Ihre übergebene Zeichenfolge eine Zeichenfolge ist, gibt es dafür eine einfache Methode.

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

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

This boolean value will return if string contains or not
0
shaishav shukla

Um auf die Antwort hier aufzubauen, können Sie eine String-Erweiterungsmethode erstellen, um die Benutzerfreundlichkeit zu erhöhen:

    public static bool ContainsIgnoreCase(this string paragraph, string Word)
    {
        return new CultureInfo("en-US").CompareInfo.IndexOf(paragraph, Word, CompareOptions.IgnoreCase) >= 0;
    }
0