Vergleichen von Zeichenfolgen in C#

Sie vergleichen Zeichenfolgen, um eine von zwei Fragen zu beantworten: Sind diese beiden Zeichenfolgen gleich? Oder in welcher Reihenfolge sortieren diese Zeichenfolgen? Mit C# können Sie zwei unabhängige Faktoren steuern, wenn Sie eine der beiden Fragen beantworten:

• Groß-/Kleinschreibung – ob "Hello" und "hello" als gleich behandelt werden.
• Vergleichsart — ordinal (vergleicht den Binärwert der einzelnen Zeichen) oder kultursensitiv (wendet die sprachlichen Regeln einer Kultur an).

Die StringComparison Enumeration kombiniert diese Faktoren in einem einzelnen Wert, den Sie an Vergleichsmethoden übergeben.

Auf Gleichheit prüfen

Die Methode String.Equals und der Operator == führen standardmäßig einen ordinalen, die Groß- und Kleinschreibung berücksichtigenden Vergleich durch. Der Ordinalvergleich überprüft den Binärwert jedes Zeichens, sodass es schnell ist und dasselbe Ergebnis auf jedem Computer liefert. Sie können Ihre Absicht explizit festlegen, indem Sie die Überladung aufrufen, die einen StringComparison Wert akzeptiert:

string root = @"C:\users";
string root2 = @"C:\Users";

// Equals and == both perform a case-sensitive, ordinal comparison.
Console.WriteLine(root.Equals(root2));
// => False
Console.WriteLine(root == root2);
// => False

// Pass a StringComparison value to state the intent explicitly.
Console.WriteLine(root.Equals(root2, StringComparison.Ordinal));
// => False

Um die Groß-/Kleinschreibung zu ignorieren und dabei die Ordnungssemantik beizubehalten, übergeben Sie StringComparison.OrdinalIgnoreCase:

string root = @"C:\users";
string root2 = @"C:\Users";

// OrdinalIgnoreCase compares the binary values but ignores case.
bool equalIgnoringCase = string.Equals(root, root2, StringComparison.OrdinalIgnoreCase);
Console.WriteLine(equalIgnoringCase);
// => True

Für die Sortierreihenfolge vergleichen

Um die Sortierreihenfolge anstelle der Gleichheit zu bestimmen, verwenden Sie String.Compare. Sie gibt eine negative Zahl, null oder eine positive Zahl zurück, um anzugeben, ob die erste Zeichenfolge vor, an derselben Position wie oder nach der zweiten sortiert wird:

string first = "Avocado";
string second = "Banana";

// Compare returns a negative number, zero, or a positive number
// to indicate sort order. Specify the comparison type explicitly.
int order = string.Compare(first, second, StringComparison.Ordinal);
Console.WriteLine(order < 0
    ? $"'{first}' sorts before '{second}'."
    : $"'{first}' sorts at or after '{second}'.");
// => 'Avocado' sorts before 'Banana'.

Vergleichen mit Konstanten mit Musterabgleich is oder switch

Wenn der Wert, mit dem Sie vergleichen, eine Konstante ist, können Sie den is Operator mit einem Konstantenmuster als lesbare Alternative zu == verwenden:

string status = "Ready";

// When the right operand is a constant, the is operator and a
// constant pattern read as an alternative to ==.
if (status is "Ready")
{
    Console.WriteLine("The system is ready.");
}
// => The system is ready.

Verwenden Sie einen switch Ausdruck, um eine Zeichenfolge mit mehreren Konstanten zu vergleichen. Jeder Arm testet ein Konstantenmuster, und das Verwerfenmuster (_) behandelt jeden Wert, der nicht übereinstimmt. Im nächsten Beispiel wird ein Richtungsstichwort einer Reiseanweisung zugeordnet:

foreach (string heading in new[] { "North", "South", "East", "West", "NE" })
{
    // A switch expression matches each constant pattern in turn and
    // returns the first match. The discard (_) handles every other value.
    string instruction = heading switch
    {
        "North" => "Travel due North for 10 km.",
        "South" => "Travel due South for 10 km.",
        "East" => "Travel due East for 10 km.",
        "West" => "Travel due West for 10 km.",
        _ => $"Unknown heading: {heading}.",
    };
    Console.WriteLine(instruction);
}
// => Travel due North for 10 km.
// => Travel due South for 10 km.
// => Travel due East for 10 km.
// => Travel due West for 10 km.
// => Unknown heading: NE.

Ein switch-Ausdruck, der Zeichenfolgenkonstanten testet, führt denselben Vergleich mit Berücksichtigung der Groß-/Kleinschreibung anhand der Ordinalwerte wie == durch, sodass "north" nicht dem "North"-Arm entspricht.

Auswählen des richtigen Vergleichs

Wählen Sie die Vergleichsart basierend auf den Daten aus, nicht aus der Gewohnheit:

• Für Bezeichner, Dateipfade, Protokoll-Token und anderen maschinendefinierten Text verwenden Sie Ordinal (oder OrdinalIgnoreCase, um die Groß-/Kleinschreibung zu ignorieren). Der Ordinalvergleich ist schnell und kulturübergreifend konsistent.
• Verwenden Sie CurrentCulture für Text, den Benutzer lesen und sortieren, z. B. Namen oder Produkttitel, damit die Reihenfolge den Erwartungen des Benutzers entspricht.

Der kulturbewusste Vergleich wendet sprachliche Regeln an, die je nach Kultur variieren und überraschende Ergebnisse erzielen können. Beispielsweise behandeln einige Kulturen "ss" und "ß" als gleich, und die Reihenfolge von Zeichenfolgen kann sich zwischen verschiedenen Maschinen ändern. Aufgrund dieser Variabilität sollten Sie einen kulturbewussten Vergleich für echten Text in natürlicher Sprache reservieren und dieselbe Vergleichsart verwenden, wenn Sie eine Sammlung sortieren und durchsuchen.

Eine eingehende Behandlung von kultursensitiven Vergleichen, einschließlich Globalisierungsaspekten und Plattformunterschieden, finden Sie unter Bewährte Methoden zum Vergleichen von Zeichenfolgen in .NET.

Siehe auch

• Best-Methoden zum Vergleichen von Zeichenfolgen in .NET
• Suchzeichenfolgen in C#
• StringComparison
• String.Compare