Vergleichen und Sortieren von Daten für eine bestimmte Kultur

Die alphabetische Reihenfolge und die Konventionen für Reihenfolgen anderer Elemente unterscheiden sich für die verschiedenen Kulturen. Bei der Sortierreihenfolge kann beispielsweise zwischen Groß- und Kleinschreibung unterschieden werden oder nicht. Darüber hinaus kann die Sortierung anhand der Phonetik bzw. der Darstellung der Zeichen erfolgen. In ostasiatischen Sprachen erfolgt die Sortierung anhand der Anzahl der Striche und der Radikale der Ideogramme. Sortierungen können sich auch aufgrund der grundlegenden Reihenfolge unterscheiden, die in einer Sprache und Kultur für das Alphabet verwendet wird. Im Schwedischen gibt es beispielsweise das Zeichen "Æ", das im Alphabet nach dem Zeichen "Z" einsortiert ist. Im Deutschen gibt es dieses Zeichen auch, aber es entspricht bei der Sortierung "ae", d. h. es erscheint im Alphabet nach dem "A". Eine weltweit einsetzbare Anwendung muss in der Lage sein, Daten auf kultureller Basis zu vergleichen und zu sortieren, um kultur- und sprachspezifische Sortierkonventionen zu unterstützen.

Hinweis   In einigen Szenarios ist ein kulturabhängiges Verhalten nicht erwünscht. Weitere Informationen über die Situationen, in denen kulturunabhängige Operationen durchgeführt werden sollten, und die entsprechenden Vorgehensweisen finden Sie unter Kulturunabhängige Zeichenfolgenoperationen.

Vergleichen von Zeichenfolgen

Die CompareInfo-Klasse umfasst mehrere Methoden, die Sie zum Vergleichen von kulturabhängigen Zeichenfolgen verwenden können. Die CultureInfo-Klasse verfügt über eine CompareInfo-Eigenschaft, bei der es sich um eine Instanz dieser Klasse handelt. Diese Eigenschaft definiert, wie Zeichenfolgen für eine bestimmte Kultur verglichen und sortiert werden. Die String.Compare-Methode verwendet die Informationen in der CompareInfo-Eigenschaft, um Zeichenfolgen zu vergleichen. Wenn string1 kleiner als string2 ist, gibt die String.Compare-Methode eine negative Ganzzahl zurück, wenn string1 und string2 gleich sind, gibt sie 0 (null) zurück, und wenn string1 größer als string2 ist, gibt sie eine positive Ganzzahl zurück.

Anhand des folgenden Codebeispiels wird dargestellt, wie Zeichenfolgen in Abhängigkeit davon, welche Kultur zum Durchführen des Vergleichs verwendet wurde, von der String.Compare-Methode unterschiedlich ausgewertet werden können. Zunächst wird CurrentCulture auf "da-DK" für die Kultur "Dänisch (Dänemark)" festgelegt, und die Zeichenfolgen "Apple" und "Æble" werden verglichen. Im Dänischen wird das Zeichen "Æ" als einzelner Buchstabe betrachtet und im Alphabet nach "Z" einsortiert. Demnach ist die Zeichenfolge "Æble" in der dänischen Kultur größer als "Apple". Anschließend wird CurrentCulture auf "en-US" für die Kultur Englisch (USA) festgelegt, und die Zeichenfolgen "Apple" und "Æble" werden erneut verglichen. In diesem Fall ist die Zeichenfolge "Æble" kleiner als "Apple". Im Englischen wird das Zeichen "Æ" als Sonderzeichen betrachtet und im Alphabet vor dem Buchstaben "A" einsortiert.

Imports System.Globalization
Imports System.Threading

Public Class TestClass
   Public Shared Sub Main()
      Dim str1 As String = "Apple"
      Dim str2 As String = "Æble"

      ' Set the current culture to Danish in Denmark.
      Thread.CurrentThread.CurrentCulture = New CultureInfo("da-DK")
      Dim result1 As Integer = [String].Compare(str1, str2)
      Console.WriteLine("When the CurrentCulture is ""da-DK"",")
      Console.WriteLine("the result of comparing_{0} with {1} is: {2}", 
                        str1, str2, result1)

      ' Set the current culture to English in the U.S.
      Thread.CurrentThread.CurrentCulture = New CultureInfo("en-US")
      Dim result2 As Integer = [String].Compare(str1, str2)
      Console.WriteLine("When the CurrentCulture is""en-US"",")
      Console.WriteLine("the result of comparing {0} with {1} is: {2}", 
                        str1, str2,result2)
   End Sub
End Class
' The example displays the following output:
'    When the CurrentCulture is "da-DK",
'    the result of comparing Apple with Æble is: -1
'    
'    When the CurrentCulture is "en-US",
'    the result of comparing Apple with Æble is: 1

using System;
using System.Globalization;
using System.Threading;

public class CompareStringSample
{
   public static void Main()
   {
      string str1 = "Apple";
      string str2 = "Æble"; 

      // Sets the CurrentCulture to Danish in Denmark.
      Thread.CurrentThread.CurrentCulture = new CultureInfo("da-DK");
      // Compares the two strings.
      int result1 = String.Compare(str1, str2);
      Console.WriteLine("\nWhen the CurrentCulture is \"da-DK\",\nthe " + 
                        "result of comparing {0} with {1} is: {2}", str1, str2, 
                        result1);

      // Sets the CurrentCulture to English in the U.S.
      Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
      // Compares the two strings.
      int result2 = String.Compare(str1, str2);
      Console.WriteLine("\nWhen the CurrentCulture is \"en-US\",\nthe " + 
                        "result of comparing {0} with {1} is: {2}", str1, str2, 
                        result2);
   }
}
// The example displays the following output:
//    When the CurrentCulture is "da-DK",
//    the result of comparing Apple with Æble is: -1
//    
//    When the CurrentCulture is "en-US",
//    the result of comparing Apple with Æble is: 1

Weitere Informationen zum Vergleichen von Zeichenfolgen finden Sie unter Vergleichen von Zeichenfolgen.

Verwenden von alternativen Sortierreihenfolgen

Einige Kulturen unterstützten mehr als eine Sortierreihenfolge. Beispielsweise unterstützt die Kultur Chinesisch (VR China) mit dem Namen "zh-CN" die Sortierung nach Aussprache (Standard) sowie die Sortierung nach Anzahl der Striche. Wenn die Anwendung ein CultureInfo-Objekt mit einem Kulturnamen erstellt (z. B. "zh-CN"), wird die Standardsortierreihenfolge verwendet. Um eine andere Sortierreihenfolge anzugeben, sollte die Anwendung ein CultureInfo-Objekt mit dem Bezeichner für die andere Sortierreihenfolge erstellen. Anschließend sollte die Anwendung ein CompareInfo-Objekt zur Verwendung in Zeichenfolgenvergleichen aus CompareInfo abrufen. Alternativ kann die Anwendung mit der CompareInfo.GetCompareInfo-Methode direkt ein CompareInfo-Objekt erstellen und den Bezeichner für die alternative Sortierreihenfolge angeben.

Die folgende Tabelle enthält die Kulturen, die unterschiedliche Sortierreihenfolgen unterstützen, sowie die Bezeichner für die standardmäßigen und die alternativen Sortierreihenfolgen.

Suchen von Zeichenfolgen

Die Anwendung kann die überladene CompareInfo.IndexOf-Methode verwenden, um den nullbasierten Index eines Zeichens oder einer untergeordneten Zeichenfolge innerhalb einer angegebenen Zeichenfolge abzurufen. Die Methode ruft eine negative Ganzzahl ab, wenn das Zeichen oder die untergeordnete Zeichenfolge in der angegebenen Zeichenfolge nicht gefunden wird. Bei der Suche nach einem angegebenen Zeichen mit CompareInfo.IndexOf sollte die Anwendung berücksichtigen, dass die Methodenüberladungen, die einen CompareOptions-Parameter akzeptieren, den Vergleich anders durchführen als die Methodenüberladungen, die diesen Parameter nicht akzeptieren. Die Methodenüberladungen, die nach einem Zeichentyp suchen und keinen CompareOptions-Parameter akzeptieren, führen eine kulturabhängige Suche durch. Wenn also ein Unicode-Wert ein zuvor gebildetes Zeichen darstellt (z. B. die Ligatur "Æ" (\u00C6)), wird dieses je nach Kultur möglicherweise als äquivalent mit einer seiner Komponenten in der richtigen Sequenz betrachtet (z. B. "AE" (\u0041\u0045)). Zum Durchführen einer ordinalen (nicht kulturabhängigen) Suche, bei der zwei Zeichentypen nur dann als gleich betrachtet werden, wenn deren Unicode-Werte übereinstimmen, sollte die Anwendung eine der CompareInfo.IndexOf-Überladungen verwenden, die einen CompareOptions-Parameter akzeptieren, und den Parameter auf den Ordinalwert festlegen.

Die Anwendung kann auch Überladungen der String.IndexOf-Methode verwenden, die nach einem Zeichen suchen, um eine ordinale (kulturunabhängige) Suche durchzuführen. Die Überladungen dieser Methode, die nach einer Zeichenfolge suchen, führen eine kulturabhängige Suche durch.

Im folgenden Codebeispiel wird der von der Kultur abhängige Unterschied zwischen den Ergebnissen dargestellt, die von der IndexOf-Methode abgerufen werden. Es wird ein CultureInfo-Objekt für die Kultur Dänisch (Dänemark) mit dem Namen "da-DK" erstellt. Anschließend werden Überladungen der CompareInfo.IndexOf-Methode für eine Suche nach dem Zeichen "Æ" in den Zeichenfolgen "Æble" und "aeble" verwendet. Beachten Sie, dass für die Kultur "da-DK" mit der CompareInfo.IndexOf-Methode, die einen CompareOptions-Parameter akzeptiert, der auf den Ordinal festgelegt ist, dasselbe Ergebnis abgerufen wird wie mit der gleichen Methode, die diesen Parameter nicht akzeptiert. Das Zeichen "Æ" wird nur als äquivalent mit dem Unicode-Codewert \u00E6 betrachtet.

Imports System.Globalization
Imports System.Threading

Public Class CompareClass
   Public Shared Sub Main()
      Dim str1 As String = "Æble"
      Dim str2 As String = "aeble"
      Dim find As Char = "Æ"

      ' Creates a CultureInfo for Danish in Denmark.
      Dim ci As New CultureInfo("da-DK")

      Dim result1 As Integer = ci.CompareInfo.IndexOf(str1, find)
      Dim result2 As Integer = ci.CompareInfo.IndexOf(str2, find)
      Dim result3 As Integer = ci.CompareInfo.IndexOf(str1, find, _ 
         CompareOptions.Ordinal)
      Dim result4 As Integer = ci.CompareInfo.IndexOf(str2, find, _
         CompareOptions.Ordinal)      

      Console.WriteLine("CultureInfo is set to {0}", 
                        ci.DisplayName)
      Console.WriteLine()
      Console.WriteLine("Using CompareInfo.IndexOf(string, char) method")
      Console.WriteLine("the result of searching for {0} in the string {1} is: {2}", 
                        find, str1, result1)
      Console.WriteLine()
      Console.WriteLine("Using CompareInfo.IndexOf(string, char) method")
      Console.WriteLine("the result of searching for {0} in the string {1} is: {2}", 
                        find, str2, result2)
      Console.WriteLine()
      Console.WriteLine("Using CompareInfo.IndexOf(string, char, CompareOptions) method")
      Console.WriteLine("the result of searching for {0} in the string {1} is: {2}", 
                        find, str1, result3)
      Console.WriteLine()
      Console.WriteLine("Using CompareInfo.IndexOf(string, char, CompareOptions) method")
      Console.WriteLine("the result of searching for {0} in the string {1} is: {2}", 
                        find, str2, result4)
   End Sub
End Class
' The example displays the following output:
'    CultureInfo is set to Danish (Denmark)
'    
'    Using CompareInfo.IndexOf(string, char) method
'    the result of searching for Æ in the string Æble is: 0
'    
'    Using CompareInfo.IndexOf(string, char) method
'    the result of searching for Æ in the string aeble is: -1
'    
'    Using CompareInfo.IndexOf(string, char, CompareOptions) method
'    the result of searching for Æ in the string Æble is: 0
'    
'    Using CompareInfo.IndexOf(string, char, CompareOptions) method
'    the result of searching for Æ in the string aeble is: -1

using System;
using System.Globalization;
using System.Threading;

public class CompareClass
{

   public static void Main()
   {
      string str1 = "Æble";
      string str2 = "aeble"; 
      char find = 'Æ';

      // Creates a CultureInfo for Danish in Denmark.
      CultureInfo ci= new CultureInfo("da-DK");

      int result1 = ci.CompareInfo.IndexOf(str1, find);
      int result2 = ci.CompareInfo.IndexOf(str2, find);
      int result3 = ci.CompareInfo.IndexOf(str1, find,   
         CompareOptions.Ordinal);
      int result4 = ci.CompareInfo.IndexOf(str2, find, 
         CompareOptions.Ordinal);

      Console.WriteLine("\nCultureInfo is set to {0} ", ci.DisplayName);
      Console.WriteLine("\nUsing CompareInfo.IndexOf(string, char) " + 
         "method\nthe result of searching for {0} in the string {1} is: {2}", 
         find, str1, result1);
      Console.WriteLine("\nUsing CompareInfo.IndexOf(string, char) " + 
         "method\nthe result of searching for {0} in the string {1} is: {2}",  
         find, str2, result2);
      Console.WriteLine("\nUsing CompareInfo.IndexOf(string, char, " +
         "CompareOptions) method\nthe result of searching for {0} in the " + 
         "string {1} is: {2}", find, str1, result3);
      Console.WriteLine("\nUsing CompareInfo.IndexOf(string, char, " +
         "CompareOptions) method\nthe result of searching for {0} in the " + 
         "string {1} is: {2}", find, str2, result4);
   }
}
// The example displays the following output:
//    CultureInfo is set to Danish (Denmark)
//    
//    Using CompareInfo.IndexOf(string, char) method
//    the result of searching for Æ in the string Æble is: 0
//    
//    Using CompareInfo.IndexOf(string, char) method
//    the result of searching for Æ in the string aeble is: -1
//    
//    Using CompareInfo.IndexOf(string, char, CompareOptions) method
//    the result of searching for Æ in the string Æble is: 0
//    
//    Using CompareInfo.IndexOf(string, char, CompareOptions) method
//    the result of searching for Æ in the string aeble is: -1

Wenn die Anwendung CultureInfo ci = new CultureInfo ("da-DK") durch CultureInfo ci = new CultureInfo ("en-US") ersetzt, werden mit der CompareInfo.IndexOf-Methode, deren CompareOptions-Parameter auf Ordinal festgelegt ist, und mit der gleichen Methode ohne diesen Parameter unterschiedliche Ergebnisse abgerufen. Der von der CompareInfo.IndexOf-Methode durchgeführte kulturabhängige Vergleich wertet das Zeichen "Æ" als äquivalent mit den Komponenten "ae" aus. Der ordinale (kulturunabhängige) Vergleich, der von der CompareInfo.IndexOf-Methode durchgeführt wird, betrachtet die Zeichen "Æ" und "ae" nicht als äquivalent, da ihre Unicode-Codewerte nicht übereinstimmen.

Wenn Sie den Code für die Kultur "en-US" (Englisch (USA)) erneut kompilieren und ausführen, wird die folgende Ausgabe erzeugt:

The CurrentCulture property is set to English (United States) 

Using CompareInfo.IndexOf(string, char) method
the result of searching for Æ in the string Æble is: 0

Using CompareInfo.IndexOf(string, char) method
the result of searching for Æ in the string aeble is: 0

Using CompareInfo.IndexOf(string, char, CompareOptions) method
the result of searching for Æ in the string Æble is: 0

Using CompareInfo.IndexOf(string, char, CompareOptions) method
the result of searching for Æ in the string aeble is: -1

Sortieren von Zeichenfolgen

Die Array-Klasse stellt eine überladene Array.Sort-Methode bereit, mit der die Anwendung Arrays auf Basis der CurrentCulture-Eigenschaft sortieren kann. Im folgenden Beispiel wird ein Array mit drei Zeichenfolgen erstellt. Zuerst wird die Thread.CurrentThread.CurrentCulture-Eigenschaft auf "en-US" festgelegt, und die Array.Sort-Methode wird aufgerufen. Die sich daraus ergebende Sortierreihenfolge basiert auf den Sortierkonventionen für die Kultur Englisch (USA). Anschließend wird die Thread.CurrentThread.CurrentCulture-Eigenschaft auf "da-DK" festgelegt, und die Array.Sort-Methode wird erneut aufgerufen. Die sich daraus ergebende Sortierreihenfolge unterscheidet sich von den Ergebnissen für "en-US", weil die Sortierkonventionen für die Kultur "da-DK" verwendet werden.

Imports System.Globalization
Imports System.IO
Imports System.Threading

Public Class TextToFile   
   Public Shared Sub Main()
      ' Creates and initializes a new array to store 
      ' these date/time objects.
      Dim stringArray() As String = { "Apple", "Æble", "Zebra"}

      ' Displays the values of the array.
      Console.WriteLine("The original string array:")
      PrintIndexAndValues(stringArray)

      ' Set the CurrentCulture to "en-US".
      Thread.CurrentThread.CurrentCulture = New CultureInfo("en-US")
      ' Sort the values of the Array.
      Array.Sort(stringArray)

      ' Display the values of the array.
      Console.WriteLine("After sorting for the ""en-US"" culture:")
      PrintIndexAndValues(stringArray)

      ' Set the CurrentCulture to "da-DK".
      Thread.CurrentThread.CurrentCulture = New CultureInfo("da-DK")
      ' Sort the values of the Array.
      Array.Sort(stringArray)

      ' Displays the values of the Array.
      Console.WriteLine("After sorting for the culture ""da-DK"":")
      PrintIndexAndValues(stringArray)
   End Sub

   Public Shared Sub PrintIndexAndValues(myArray() As String)
      For i As Integer = myArray.GetLowerBound(0) To myArray.GetUpperBound(0)
         Console.WriteLine("[{0}]: {1}", i, myArray(i))
      Next
      Console.WriteLine()
   End Sub 
End Class
' The example displays the following output:
'       The original string array:
'       [0]: Apple
'       [1]: Æble
'       [2]: Zebra
'       
'       After sorting for the "en-US" culture:
'       [0]: Æble
'       [1]: Apple
'       [2]: Zebra
'       
'       After sorting for the culture "da-DK":
'       [0]: Apple
'       [1]: Zebra
'       [2]: Æble

using System;
using System.Globalization;
using System.Threading;

public class ArraySort 
{
   public static void Main(String[] args) 
   {
      // Create and initialize a new array to store the strings.
      string[] stringArray = { "Apple", "Æble", "Zebra"};

      // Display the values of the array.
      Console.WriteLine( "The original string array:");
      PrintIndexAndValues(stringArray);

      // Set the CurrentCulture to "en-US".
      Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
      // Sort the values of the array.
      Array.Sort(stringArray);

      // Display the values of the array.
      Console.WriteLine("After sorting for the culture \"en-US\":");
      PrintIndexAndValues(stringArray); 

      // Set the CurrentCulture to "da-DK".
      Thread.CurrentThread.CurrentCulture = new CultureInfo("da-DK");
      // Sort the values of the Array.
      Array.Sort(stringArray);

      // Display the values of the array.
      Console.WriteLine("After sorting for the culture \"da-DK\":");
      PrintIndexAndValues(stringArray); 
   }
   public static void PrintIndexAndValues(string[] myArray)  
   {
      for (int i = myArray.GetLowerBound(0); i <= 
            myArray.GetUpperBound(0); i++ )
         Console.WriteLine("[{0}]: {1}", i, myArray[i]);
      Console.WriteLine();      
   }
}
// The example displays the following output:
//       The original string array:
//       [0]: Apple
//       [1]: Æble
//       [2]: Zebra
//       
//       After sorting for the "en-US" culture:
//       [0]: Æble
//       [1]: Apple
//       [2]: Zebra
//       
//       After sorting for the culture "da-DK":
//       [0]: Apple
//       [1]: Zebra
//       [2]: Æble

Verwenden von Sortierschlüsseln

Sortierschlüssel werden zum Unterstützen von kulturabhängigen Sortierungen verwendet. Anhand des Unicode-Standards werden jedem Zeichen in einer Zeichenfolge mehrere Sortiergewichtungskategorien zugeordnet. Dies umfasst die Gewichtung nach Groß-/Kleinschreibung, alphabetischer Folge und diakritischen Zeichen. Als Repository für diese Gewichtungen für eine bestimmte Zeichenfolge fungiert ein Sortierschlüssel. Ein Sortierschlüssel kann z. B. eine Zeichenfolge mit alphabetischen Gewichtungen enthalten, dann eine Zeichenfolge mit Gewichtungen nach Groß-/Kleinschreibung usw. Weitere Informationen zu Sortierschlüsseln finden Sie im Unicode-Standard auf der Unicode-Homepage.

In .NET Framework ordnet die SortKey-Klasse Zeichenfolgen den entsprechenden Sortierschlüsseln zu und umgekehrt. Die Anwendung kann die CompareInfo.GetSortKey-Methode verwenden, um einen Sortierschlüssel für eine von Ihnen angegebene Zeichenfolge zu erstellen. Der Sortierschlüssel für eine angegebene Zeichenfolge ist eine Sequenz von Bytes, die sich in Abhängigkeit vom jeweils angegebenen CurrentCulture-Wert und CompareOptions-Wert unterscheiden können. Wenn die Anwendung beim Erstellen eines Sortierschlüssels beispielsweise den IgnoreCase-Wert angibt, wird bei einem Zeichenfolgenvergleich mit diesem Sortierschlüssel die Groß-/Kleinschreibung ignoriert.

Nach dem Erstellen eines Sortierschlüssels für eine Zeichenfolge kann die Anwendung diesen als Parameter an Methoden übergeben, die von der SortKey-Klasse bereitgestellt werden. Die SortKey.Compare-Methode ermöglicht einen Vergleich von Sortierschlüsseln. Da diese Methode einen einfachen Byte-pro-Byte-Vergleich durchführt, ist ihre Verwendung viel schneller als die der String.Compare-Methode. In sortierintensiven Anwendungen lässt sich die Leistung erhöhen, indem für alle verwendeten Zeichenfolgen Sortierschlüssel generiert und gespeichert werden. Wenn eine Sortierung oder ein Vergleich erforderlich ist, kann die Anwendung die Sortierschlüssel anstelle der Zeichenfolgen verwenden.

Im folgenden Codebeispiel werden Sortierschlüssel für zwei Zeichenfolgen erstellt, wenn CurrentCulture auf "da-DK" festgelegt ist. Die beiden Zeichenfolgen werden mithilfe der SortKey.Compare-Methode verglichen, und das Ergebnis wird angezeigt. Wenn Zeichenfolge1 kleiner als Zeichenfolge2 ist, gibt die -Methode eine negative Ganzzahl zurück, wenn Zeichenfolge1 und Zeichenfolge2 gleich sind, gibt Sie 0 (null) zurück, und wenn Zeichenfolge1 größer als Zeichenfolge2 ist, gibt sie eine positive Ganzzahl zurück. Anschließend wird die Thread.CurrentThread.CurrentCulture-Eigenschaft auf "en-US" festgelegt, und es werden Sortierschlüssel für dieselben Zeichenfolgen erstellt. Die Sortierschlüssel für die Zeichenfolgen werden verglichen, und das Ergebnis wird angezeigt. Die Ergebnisse der Sortierung unterscheiden sich in Abhängigkeit von der CurrentCulture-Einstellung. Zwar stimmt das Ergebnis des folgenden Beispiels mit dem Ergebnis des Vergleichs dieser Zeichenfolgen unter Vergleichen von Zeichenfolgen weiter oben in diesem Thema überein, die Verwendung der SortKey.Compare-Methode ist jedoch schneller als die Verwendung der String.Compare-Methode.

Imports System.Globalization
Imports System.Threading

Public Class SortKeySample
   Public Shared Sub Main()
      Dim str1 As [String] = "Apple"
      Dim str2 As [String] = "Æble"

      ' Set the CurrentCulture to "da-DK".
      Dim dk As New CultureInfo("da-DK")
      Thread.CurrentThread.CurrentCulture = dk

      ' Create a culturally sensitive sort key for str1.
      Dim sc1 As SortKey = dk.CompareInfo.GetSortKey(str1)
      ' Create a culturally sensitive sort key for str2.
      Dim sc2 As SortKey = dk.CompareInfo.GetSortKey(str2)

      ' Compare the two sort keys and display the results.
      Dim result1 As Integer = SortKey.Compare(sc1, sc2)
      Console.WriteLine("When the  current culture is ""da-DK"",")
      Console.WriteLine("the result of comparing {0} with {1} is: {2}", 
                        str1, str2, result1)
      Console.WriteLine()

      ' Set the CurrentCulture to "en-US".
      Dim enus As New CultureInfo("en-US")
      Thread.CurrentThread.CurrentCulture = enus

      ' Create a culturally sensitive sort key for str1.
      Dim sc3 As SortKey = enus.CompareInfo.GetSortKey(str1)
      ' Create a culturally sensitive sort key for str1.
      Dim sc4 As SortKey = enus.CompareInfo.GetSortKey(str2)

      ' Compare the two sort keys and display the results.
      Dim result2 As Integer = SortKey.Compare(sc3, sc4)
      Console.WriteLine("When the CurrentCulture is ""en-US"",")
      Console.WriteLine("the result of comparing {0} with {1} is: {2}", 
                        str1, str2, result2)
   End Sub
End Class
' The example displays the following output:
'       When the  current culture is "da-DK",
'       the result of comparing Apple with Æble is: -1
'       
'       When the CurrentCulture is "en-US",
'       the result of comparing Apple with Æble is: 1

using System;
using System.Threading;
using System.Globalization;

public class SortKeySample 
{
   public static void Main(String[] args) 
   {
      String str1 = "Apple";
      String str2 = "Æble";

      // Set the CurrentCulture to "da-DK".
      CultureInfo dk = new CultureInfo("da-DK");
      Thread.CurrentThread.CurrentCulture = dk;

      // Create a culturally sensitive sort key for str1.
      SortKey sc1 = dk.CompareInfo.GetSortKey(str1);
      // Create a culturally sensitive sort key for str2.
      SortKey sc2 = dk.CompareInfo.GetSortKey(str2);

      // Compare the two sort keys and display the results.
      int result1 = SortKey.Compare(sc1, sc2);
      Console.WriteLine("When the CurrentCulture is \"da-DK\",");
      Console.WriteLine("the result of comparing {0} with {1} is: {2}\n", 
                        str1, str2, result1);

      // Set the CurrentCulture to "en-US".
      CultureInfo enus = new CultureInfo("en-US");
      Thread.CurrentThread.CurrentCulture = enus ;

      // Create a culturally sensitive sort key for str1.
      SortKey sc3 = enus.CompareInfo.GetSortKey(str1);
      // Create a culturally sensitive sort key for str1.
      SortKey sc4 = enus.CompareInfo.GetSortKey(str2);

      // Compare the two sort keys and display the results.
      int result2 = SortKey.Compare(sc3, sc4);
      Console.WriteLine("When the CurrentCulture is \"en-US\",");
      Console.WriteLine("the result of comparing {0} with {1} is: {2}", 
                        str1, str2, result2);
   }
}
// The example displays the following output:
//       When the CurrentCulture is "da-DK",
//       the result of comparing Apple with Æble is: -1
//       
//       When the CurrentCulture is "en-US",
//       the result of comparing Apple with Æble is: 1

Normalisierung

Die Anwendung kann die Zeichenfolgen vor dem Sortieren vereinheitlichen, d. h. diese sollten entweder nur in Großschreibung oder nur in Kleinschreibung vorliegen. Die Regeln für die Sortierung von Zeichenfolgen und die Groß- und Kleinschreibung sind sprachspezifisch. Beispielsweise gibt es selbst innerhalb der Sprachen, für die das lateinische Schriftsystem verwendet wird, Unterschiede bezüglich der Zusammensetzungs- und Sortierregeln. Nur in wenigen Sprachen (zu denen u. a. das Englische gehört) stimmt die Sortierreihenfolge mit der Reihenfolge der Codepunkte überein (z. B. A [65] steht vor B [66]).

Codepunkte allein sind daher keine Gewähr für ein fehlerfreies Sortieren oder Vergleichen von Zeichenfolgen. Darüber hinaus erzwingt oder gewährleistet .NET Framework nicht eine bestimmte Form der Vereinheitlichung. Sie müssen die entsprechende Vereinheitlichung in den entwickelten Anwendungen selbst durchführen.

Weitere Informationen zur Normalisierung von Zeichenfolgen finden Sie unter Normalisierung und Sortierung.

Siehe auch

Konzepte

Kulturunabhängige Zeichenfolgenoperationen

Normalisierung und Sortierung

Weitere Ressourcen

Codierung und Lokalisierung