Sztringek összehasonlítása a C-ben#

A sztringeket két kérdés egyikének megválaszolásához hasonlítja össze: "Egyenlő ez a két sztring?" vagy "Milyen sorrendben kell elhelyezni ezeket a sztringeket a rendezés során?"

A következő tényezők bonyolítják ezt a két kérdést:

  • Választhat egy sorszám- vagy nyelvi összehasonlítást.
  • Kiválaszthatja, hogy az eset számít-e.
  • Választhat kultúraspecifikus összehasonlításokat.
  • A nyelvi összehasonlítások kultúrától és platformfüggők.

Az System.StringComparison enumerálási mezők a következő lehetőségeket jelölik:

  • CurrentCulture: A karakterláncok összehasonlítása a kultúraérzékeny rendezési szabályok és az aktuális kultúra használatával.
  • CurrentCultureIgnoreCase: A sztringek összehasonlítása kulturális szempontból érzékeny rendezési szabályokkal, az aktuális kultúrával és az összehasonlítandó sztringek esetének figyelmen kívül hagyásával.
  • InvariantCulture: Hasonlítsa össze a sztringeket a kultúraérzékeny rendezési szabályok és az invariáns kultúra használatával.
  • InvariantCultureIgnoreCase: Hasonlítsa össze a sztringeket a kultúraérzékeny rendezési szabályok, az invariáns kultúra és az összehasonlítandó sztringek esetének figyelmen kívül hagyásával.
  • Sorrendi: Karakterláncok összehasonlítása sorrendi (bináris) rendezési szabályok használatával.
  • OrdinalIgnoreCase: Hasonlítsa össze a sztringeket sorszámos (bináris) rendezési szabályokkal, és figyelmen kívül hagyja az összehasonlítandó sztringek esetét.

A sztringek összehasonlításakor logikai sorrendet határoz meg közöttük. Az összehasonlításokat karakterláncok sorozatának rendezésére használják. Ha a sorozat ismert sorrendben van, könnyebben kereshető mind a szoftverek, mind az emberek számára. Más összehasonlítások is ellenőrizhetik, hogy a karakterláncok megegyeznek-e. Ezek az azonossági ellenőrzések hasonlóak az egyenlőséghez, de bizonyos eltéréseket, például a kis- és nagybetűk különbségeit figyelmen kívül hagyhatják.

Alapértelmezett sorszám-összehasonlítások

Alapértelmezés szerint a leggyakoribb műveletek:

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

bool result = root.Equals(root2);
Console.WriteLine($"Ordinal comparison: <{root}> and <{root2}> are {(result ? "equal." : "not equal.")}");

result = root.Equals(root2, StringComparison.Ordinal);
Console.WriteLine($"Ordinal comparison: <{root}> and <{root2}> are {(result ? "equal." : "not equal.")}");

Console.WriteLine($"Using == says that <{root}> and <{root2}> are {(root == root2 ? "equal" : "not equal")}");

Az alapértelmezett sorszám-összehasonlítás nem veszi figyelembe a nyelvi szabályokat a sztringek összehasonlításakor. Két sztringben hasonlítja össze az egyes Char objektumok bináris értékét. Ennek eredményeképpen az alapértelmezett ordinalszerinti összehasonlítás kis- és nagybetű-érzékeny is.

Az String.Equals, == és != operátorokkal való egyenlőség tesztelése eltér a sztringek String.CompareTo és Compare(String, String) metódusok használatával történő összehasonlításától. Mindegyik nagybetűérzékeny összehasonlítást végez. Azonban, míg az egyenlőségi tesztek sorrendi összehasonlítást végeznek, a CompareTo és Compare módszerek kultúratudatos nyelvi összehasonlítást hajtanak végre a jelenlegi kultúrát használva. A kód szándékának egyértelművé tétele egy túlterhelés meghívásával, amely explicit módon meghatározza a végrehajtandó összehasonlítás típusát.

Használhatja a is operátort és az állandó mintát alternatívaként a == helyett, ha a jobb oldali operandus egy állandó.

Kis- és nagybetűk érzéketlen összehasonlítása

A String.Equals(String, StringComparison) módszer lehetővé teszi, hogy a StringComparison értéket StringComparison.OrdinalIgnoreCase-re állítsa be, hogy kis- és nagybetűkre érzéketlen ordinális összehasonlítást végezzen. Van egy statikus String.Compare(String, String, StringComparison) metódus is, amely kis- és nagybetűkre érzéketlen ordinális összehasonlítást végez, ha az StringComparison.OrdinalIgnoreCase argumentum értékét StringComparison adja meg. Ezek az összehasonlítások a következő kódban jelennek meg:

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

bool result = root.Equals(root2, StringComparison.OrdinalIgnoreCase);
bool areEqual = String.Equals(root, root2, StringComparison.OrdinalIgnoreCase);
int comparison = String.Compare(root, root2, comparisonType: StringComparison.OrdinalIgnoreCase);

Console.WriteLine($"Ordinal ignore case: <{root}> and <{root2}> are {(result ? "equal." : "not equal.")}");
Console.WriteLine($"Ordinal static ignore case: <{root}> and <{root2}> are {(areEqual ? "equal." : "not equal.")}");
if (comparison < 0)
{
    Console.WriteLine($"<{root}> is less than <{root2}>");
}
else if (comparison > 0)
{
    Console.WriteLine($"<{root}> is greater than <{root2}>");
}
else
{
    Console.WriteLine($"<{root}> and <{root2}> are equivalent in order");
}

Ezek a módszerek az invariáns kultúra kis- és nagybetűs konvencióit használják esetfüggetlen sorrendi összehasonlítás során.

Nyelvi összehasonlítások

Számos szöveg összehasonlító metódus (például String.StartsWith) alapértelmezés szerint nyelvi szabályokat használ a jelenlegi kultúrához a bemenetek sorrendjének meghatározásához. Ezt a nyelvi összehasonlítást néha "szórendezésnek" is nevezik. Ha nyelvi összehasonlítást végez, előfordulhat, hogy egyes nonalphanumerikus Unicode-karakterekhez speciális súlyok vannak hozzárendelve. A "-" kötőjel például kis súlyú lehet ahhoz, hogy a "co-op" és a "coop" rendezési sorrendben jelenjen meg egymás mellett. Egyes nem nyomtatható vezérlőkarakterek figyelmen kívül hagyhatók. Emellett egyes Unicode-karakterek egyenértékűek lehetnek egy Char elemekből álló sorozattal. Az alábbi példamondat a "Táncolnak az utcán" kifejezést használja németül, az "ss" (U+0073 U+0073) karaktersorozatban, a "ß" (U+00DF) pedig egy másikban. Nyelvileg (Windowsban) az "ss" egyenlő a német Esszettel: a "ß" karakter mind a "en-US" és a "de-DE" kultúrákban.

string first = "Sie tanzen auf der Straße.";
string second = "Sie tanzen auf der Strasse.";

Console.WriteLine($"First sentence is <{first}>");
Console.WriteLine($"Second sentence is <{second}>");

bool equal = String.Equals(first, second, StringComparison.InvariantCulture);
Console.WriteLine($"The two strings {(equal == true ? "are" : "are not")} equal.");
showComparison(first, second);

string word = "coop";
string words = "co-op";
string other = "cop";

showComparison(word, words);
showComparison(word, other);
showComparison(words, other);
void showComparison(string one, string two)
{
    int compareLinguistic = String.Compare(one, two, StringComparison.InvariantCulture);
    int compareOrdinal = String.Compare(one, two, StringComparison.Ordinal);
    if (compareLinguistic < 0)
    {
        Console.WriteLine($"<{one}> is less than <{two}> using invariant culture");
    }
    else if (compareLinguistic > 0)
    {
        Console.WriteLine($"<{one}> is greater than <{two}> using invariant culture");
    }
    else
    {
        Console.WriteLine($"<{one}> and <{two}> are equivalent in order using invariant culture");
    }

    if (compareOrdinal < 0)
    {
        Console.WriteLine($"<{one}> is less than <{two}> using ordinal comparison");
    }
    else if (compareOrdinal > 0)
    {
        Console.WriteLine($"<{one}> is greater than <{two}> using ordinal comparison");
    }
    else
    {
        Console.WriteLine($"<{one}> and <{two}> are equivalent in order using ordinal comparison");
    }
}

Windows rendszeren a .NET 5 előtt megváltozik a "cop", a "coop" és a "co-op" rendezési sorrendje, amikor nyelvi összehasonlításról sorrendi összehasonlításra vált. A két német mondat különböző eredményeket ad a különböző összehasonlítási típusok alkalmazásával. A .NET 5 előtt a .NET globalizációs API-k nemzeti nyelvi támogatási (NLS-) kódtárakat használtak. A .NET 5-ös és újabb verzióiban a .NET globalizációs API-k a Unicode nemzetközi összetevőinek (ICU) könyvtárait használják, amelyek egységesítik a .NET globalizációs viselkedését az összes támogatott operációs rendszerben.

Adott kultúrákat használó összehasonlítások

Az alábbi példa a en-US és de-DE kultúrák objektumait tárolja CultureInfo . Az összehasonlításokat objektum CultureInfo használatával hajtjuk végre a kultúraspecifikus összehasonlítás biztosítása érdekében. Az alkalmazott kultúra hatással van a nyelvi összehasonlításokra. Az alábbi példa a két német mondatnak a "en-US" kultúrával és a "de-DE" kultúrával való összehasonlításának eredményeit mutatja be:

string first = "Sie tanzen auf der Straße.";
string second = "Sie tanzen auf der Strasse.";

Console.WriteLine($"First sentence is <{first}>");
Console.WriteLine($"Second sentence is <{second}>");

var en = new System.Globalization.CultureInfo("en-US");

// For culture-sensitive comparisons, use the String.Compare
// overload that takes a StringComparison value.
int i = String.Compare(first, second, en, System.Globalization.CompareOptions.None);
Console.WriteLine($"Comparing in {en.Name} returns {i}.");

var de = new System.Globalization.CultureInfo("de-DE");
i = String.Compare(first, second, de, System.Globalization.CompareOptions.None);
Console.WriteLine($"Comparing in {de.Name} returns {i}.");

bool b = String.Equals(first, second, StringComparison.CurrentCulture);
Console.WriteLine($"The two strings {(b ? "are" : "are not")} equal.");

string word = "coop";
string words = "co-op";
string other = "cop";

showComparison(word, words, en);
showComparison(word, other, en);
showComparison(words, other, en);
void showComparison(string one, string two, System.Globalization.CultureInfo culture)
{
    int compareLinguistic = String.Compare(one, two, en, System.Globalization.CompareOptions.None);
    int compareOrdinal = String.Compare(one, two, StringComparison.Ordinal);
    if (compareLinguistic < 0)
    {
        Console.WriteLine($"<{one}> is less than <{two}> using en-US culture");
    }
    else if (compareLinguistic > 0)
    {
        Console.WriteLine($"<{one}> is greater than <{two}> using en-US culture");
    }
    else
    {
        Console.WriteLine($"<{one}> and <{two}> are equivalent in order using en-US culture");
    }

    if (compareOrdinal < 0)
    {
        Console.WriteLine($"<{one}> is less than <{two}> using ordinal comparison");
    }
    else if (compareOrdinal > 0)
    {
        Console.WriteLine($"<{one}> is greater than <{two}> using ordinal comparison");
    }
    else
    {
        Console.WriteLine($"<{one}> and <{two}> are equivalent in order using ordinal comparison");
    }
}

A kulturális szempontból érzékeny összehasonlításokat általában a felhasználók által bevitt sztringek összehasonlítására és rendezésére használják más felhasználói sztringekkel. A sztringek karakterei és rendezési konvenciók a felhasználó számítógépének területi beállításától függően változhatnak. Az azonos karaktereket tartalmazó sztringek is eltérően rendezhetők az aktuális szál kultúrájától függően.

Nyelvi alapú rendezés és karakterláncok keresése tömbökben

Az alábbi példák bemutatják, hogyan rendezheti és kereshet sztringeket egy tömbben az aktuális kultúrától függő nyelvi összehasonlítással. Statikus Array metódusokat használ, amelyek System.StringComparer paramétert vesznek át.

Az alábbi példa bemutatja, hogyan rendezhet egy karakterlánc-tömböt az aktuális kultúra szerint.

string[] lines =
[
    @"c:\public\textfile.txt",
    @"c:\public\textFile.TXT",
    @"c:\public\Text.txt",
    @"c:\public\testfile2.txt"
];

Console.WriteLine("Non-sorted order:");
foreach (string s in lines)
{
    Console.WriteLine($"   {s}");
}

Console.WriteLine("\n\rSorted order:");

// Specify Ordinal to demonstrate the different behavior.
Array.Sort(lines, StringComparer.CurrentCulture);

foreach (string s in lines)
{
    Console.WriteLine($"   {s}");
}

A tömb rendezése után bináris kereséssel kereshet bejegyzéseket. A gyűjtemény közepén elindul egy bináris keresés, amely meghatározza, hogy a gyűjtemény melyik fele tartalmazná a keresett sztringet. Minden további összehasonlítás felére bontja a gyűjtemény fennmaradó részét. A tömb StringComparer.CurrentCulture segítségével van rendezve. A helyi függvény ShowWhere információkat jelenít meg arról, hogy hol található a sztring. Ha a sztring nem található, a visszaadott érték azt jelzi, hogy hol lenne megtalálható, ha megtalálnák.

string[] lines =
[
    @"c:\public\textfile.txt",
    @"c:\public\textFile.TXT",
    @"c:\public\Text.txt",
    @"c:\public\testfile2.txt"
];
Array.Sort(lines, StringComparer.CurrentCulture);

string searchString = @"c:\public\TEXTFILE.TXT";
Console.WriteLine($"Binary search for <{searchString}>");
int result = Array.BinarySearch(lines, searchString, StringComparer.CurrentCulture);
ShowWhere<string>(lines, result);

Console.WriteLine($"{(result > 0 ? "Found" : "Did not find")} {searchString}");

void ShowWhere<T>(T[] array, int index)
{
    if (index < 0)
    {
        index = ~index;

        Console.Write("Not found. Sorts between: ");

        if (index == 0)
        {
            Console.Write("beginning of sequence and ");
        }
        else
        {
            Console.Write($"{array[index - 1]} and ");
        }

        if (index == array.Length)
        {
            Console.WriteLine("end of sequence.");
        }
        else
        {
            Console.WriteLine($"{array[index]}.");
        }
    }
    else
    {
        Console.WriteLine($"Found at index {index}.");
    }
}

Sorszámozott rendezés és keresés a gyűjteményekben

Az alábbi kód a System.Collections.Generic.List<T> kollekciót használja stringek tárolására. A sztringek rendezése a List<T>.Sort metódussal történik. Ehhez a metódushoz olyan meghatalmazottra van szükség, aki két sztringet hasonlít össze és rendel. A String.CompareTo metódus ezt az összehasonlító függvényt biztosítja. Futtassa a mintát, és figyelje meg a sorrendet. Ez a rendezési művelet egy ordinális, kis- és nagybetűkre érzékeny rendezést használ. A statikus String.Compare metódusok használatával különböző összehasonlító szabályokat adhat meg.

List<string> lines =
[
    @"c:\public\textfile.txt",
    @"c:\public\textFile.TXT",
    @"c:\public\Text.txt",
    @"c:\public\testfile2.txt"
];

Console.WriteLine("Non-sorted order:");
foreach (string s in lines)
{
    Console.WriteLine($"   {s}");
}

Console.WriteLine("\n\rSorted order:");

lines.Sort((left, right) => left.CompareTo(right));
foreach (string s in lines)
{
    Console.WriteLine($"   {s}");
}

A rendezés után a sztringek listája bináris kereséssel kereshető. Az alábbi minta bemutatja, hogyan kereshet a rendezett listában ugyanazzal az összehasonlító függvénnyel. A helyi függvény ShowWhere a keresett szöveg helyét jeleníti meg:

List<string> lines =
[
    @"c:\public\textfile.txt",
    @"c:\public\textFile.TXT",
    @"c:\public\Text.txt",
    @"c:\public\testfile2.txt"
];
lines.Sort((left, right) => left.CompareTo(right));

string searchString = @"c:\public\TEXTFILE.TXT";
Console.WriteLine($"Binary search for <{searchString}>");
int result = lines.BinarySearch(searchString);
ShowWhere<string>(lines, result);

Console.WriteLine($"{(result > 0 ? "Found" : "Did not find")} {searchString}");

void ShowWhere<T>(IList<T> collection, int index)
{
    if (index < 0)
    {
        index = ~index;

        Console.Write("Not found. Sorts between: ");

        if (index == 0)
        {
            Console.Write("beginning of sequence and ");
        }
        else
        {
            Console.Write($"{collection[index - 1]} and ");
        }

        if (index == collection.Count)
        {
            Console.WriteLine("end of sequence.");
        }
        else
        {
            Console.WriteLine($"{collection[index]}.");
        }
    }
    else
    {
        Console.WriteLine($"Found at index {index}.");
    }
}

Mindig azonos típusú összehasonlítást használjon a rendezéshez és a kereséshez. Ha különböző összehasonlító típusokat használ a rendezéshez és a kereséshez, az váratlan eredményeket eredményez.

Az olyan gyűjteményosztályok, mint a System.Collections.Hashtable, System.Collections.Generic.Dictionary<TKey,TValue>és System.Collections.Generic.List<T> olyan konstruktorokkal rendelkeznek, amelyek paramétert System.StringComparer vesznek fel, ha az elemek vagy kulcsok típusa.string Általában, amikor csak lehet, használja ezeket a konstruktorokat, és adja meg vagy a StringComparer.Ordinal vagy a StringComparer.OrdinalIgnoreCase paramétert.

Lásd még

  • Last updated on