Vergleichen und Sortieren von Daten für eine bestimmte Kultur

Aktualisiert: November 2007

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 Compare()-Methode verwendet die Informationen in der CompareInfo-Eigenschaft, um Zeichenfolgen zu vergleichen. Wenn Zeichenfolge1 kleiner als Zeichenfolge2 ist, gibt die String.Compare-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.

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 für CurrentCulture die Sprache 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 für CurrentCulture die Sprache 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
Imports System.Globalization
Imports System.Threading
Imports Microsoft.VisualBasic

Public Class TestClass
   Public Shared Sub Main()
      Dim str1 As String = "Apple"
      Dim str2 As String = "Æble"
      
      ' Sets the CurrentCulture to Danish in Denmark.
      Thread.CurrentThread.CurrentCulture = New CultureInfo("da-DK")
      Dim result1 As Integer = [String].Compare(str1, str2)
      Console.WriteLine(ControlChars.Newline + "When the CurrentCulture _
         is ""da-DK""," + ControlChars.Newline + " the 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")
      Dim result2 As Integer = [String].Compare(str1, str2)
      Console.WriteLine(ControlChars.Newline + "When the _
         CurrentCulture is""en-US""," + ControlChars.Newline + " _
         the result of comparing {0} with {1} is: {2}", str1, _
         str2,result2)
   End Sub
End Class

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);
   }
}

Wenn Sie diesen Code ausführen, wird Folgendes ausgegeben:

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 "zh-CN" (Chinesisch (China)) 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 der LCID 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 mithilfe von GetCompareInfo() ein CompareInfo-Objekt direkt erstellen und die LCID für die andere Sortierreihenfolge angeben.

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

Kulturname	Kultur	Standardsortierreihenfolge und LCID	Alternative Sortierreihenfolge und LCID
es-ES	Spanisch (Spanien)	International: 0x00000C0A	Traditionell: 0x0000040A
zh-TW	Chinesisch (Taiwan)	Anzahl der Striche: 0x00000404	Bopomofo: 0x00030404
zh-CN	Chinesisch (China)	Aussprache: 0x00000804	Anzahl der Striche: 0x00020804
zh-HK	Chinesisch (Hongkong SAR)	Anzahl der Striche: 0x00000c04	Anzahl der Striche: 0x00020c04
zh-SG	Chinesisch (Singapur)	Aussprache: 0x00001004	Anzahl der Striche: 0x00021004
zh-MO	Chinesisch (Macau SAR)	Aussprache: 0x00001404	Anzahl der Striche: 0x00021404
ja-JP	Japanisch (Japan)	Standard: 0x00000411	Unicode: 0x00010411
ko-KR	Koreanisch (Korea)	Standard: 0x00000412	Koreanisch Xwansung – Unicode: 0x00010412
de-DE	Deutsch (Deutschland)	Wörterbuch: 0x00000407	Telefonbuchsortierung DIN: 0x00010407
hu-HU	Ungarisch (Ungarn)	Standard: 0x0000040e	Technische Sortierung: 0x0001040e
ka-GE	Georgisch (Georgien)	Traditionell: 0x00000437	Moderne Sortierung: 0x00010437

Suchen von Zeichenfolgen

Die Anwendung kann die überladene 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 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 Dänisch (Dänemark) mit der Bezeichnung "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
Imports System.Globalization
Imports System.Threading
Imports Microsoft.VisualBasic

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(ControlChars.Newline + "CultureInfo is set to _
         {0}", ci.DisplayName)
      Console.WriteLine(ControlChars.Newline + "Using _
         CompareInfo.IndexOf(string, char) method" + _
         ControlChars.Newline + " the result of searching for {0} in the _
         string {1} is: {2}", find, str1, result1)
      Console.WriteLine(ControlChars.Newline + "Using _
         CompareInfo.IndexOf(string, char) method" + _
         ControlChars.Newline + " the result of searching for {0} in the _
         string {1} is: {2}", find, str2, result2)
      Console.WriteLine(ControlChars.Newline + "Using _
         CompareInfo.IndexOf(string, char, CompareOptions) method" + _
         ControlChars.Newline + " the result of searching for {0} in the _
         string {1} is: {2}", find, str1, result3)
      Console.WriteLine(ControlChars.Newline + "Using _
         CompareInfo.IndexOf(string, char, CompareOptions) method" + _
         ControlChars.Newline + " the result of searching for {0} in the _
         string {1} is: {2}", find, str2, result4)
   End Sub
End Class

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);
   }
}

Dieser Code erzeugt die folgende Ausgabe:

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 IndexOf()-Methode, deren CompareOptions-Parameter auf Ordinal festgelegt ist, und mit der gleichen Methode ohne diesen Parameter unterschiedliche Ergebnisse abgerufen. Der von der 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 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 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. Zunächst wird die CurrentCulture-Eigenschaft auf "en-US" (Englisch (USA)) festgelegt und die Sort()-Methode aufgerufen. Die sich daraus ergebende Sortierreihenfolge basiert auf den Sortierkonventionen für die Kultur Englisch (USA). Anschließend wird die CurrentCulture-Eigenschaft auf "da-DK" (Dänisch (Dänemark)) festgelegt und die Array.Sort-Methode 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
Imports System.Threading
Imports System.IO
Imports System.Globalization
Imports Microsoft.VisualBasic

Public Class TextToFile   
   Public Shared Sub Main()
      Dim str1 As [String] = "Apple"
      Dim str2 As [String] = "Æble"
      Dim str3 As [String] = "Zebra"
      
      ' Creates and initializes a new Array to store 
      ' these date/time objects.
      Dim stringArray As Array = Array.CreateInstance(GetType([String]), _
         3)
      stringArray.SetValue(str1, 0)
      stringArray.SetValue(str2, 1)
      stringArray.SetValue(str3, 2)
      
      ' Displays the values of the Array.
      Console.WriteLine(ControlChars.Newline + "The Array initially _
         contains the following strings:")
      PrintIndexAndValues(stringArray)
      
      ' Sets the CurrentCulture to "en-US".
      Thread.CurrentThread.CurrentCulture = New CultureInfo("en-US")
      ' Sorts the values of the Array.
      Array.Sort(stringArray)
      
      ' Displays the values of the Array.
      Console.WriteLine(ControlChars.Newline + "After sorting for the _
         culture ""en-US"":")
      PrintIndexAndValues(stringArray)
      
      ' Sets 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(ControlChars.Newline + "After sorting for the _
         culture ""da-DK"":")
      PrintIndexAndValues(stringArray)
   End Sub

   Public Shared Sub PrintIndexAndValues(myArray As Array)
      Dim i As Integer
      For i = myArray.GetLowerBound(0) To myArray.GetUpperBound(0)
         Console.WriteLine(ControlChars.Tab + "[{0}]:" + _
            ControlChars.Tab + "{1}", i, myArray.GetValue(i))
      Next i
   End Sub 
End Class

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

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

      // Creates and initializes a new Array to store the strings.
      Array stringArray = Array.CreateInstance( typeof(String), 3 );
      stringArray.SetValue(str1, 0 );
      stringArray.SetValue(str2, 1 );
      stringArray.SetValue(str3, 2 );

      // Displays the values of the Array.
      Console.WriteLine( "\nThe Array initially contains the following 
            strings:" );
      PrintIndexAndValues(stringArray);

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

      // Displays the values of the Array.
      Console.WriteLine( "\nAfter sorting for the culture \"en-US\":" );
      PrintIndexAndValues(stringArray); 

      // Sets 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( "\nAfter sorting for the culture \"da-DK\":" );
      PrintIndexAndValues(stringArray); 
   }
   public static void PrintIndexAndValues(Array myArray)  
   {
      for ( int i = myArray.GetLowerBound(0); i <= 
            myArray.GetUpperBound(0); i++ )
      Console.WriteLine( "\t[{0}]:\t{1}", i, myArray.GetValue( i ) );
   }
}

Dieser Code erzeugt die folgende Ausgabe:

The Array initially contains the following strings:
   [0]:   Apple
   [1]:   Æble
   [2]:   Zebra

After sorting for the culture "en-US":
   [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üsselkonzepten finden Sie unter "The Unicode Standard" unter www.unicode.org.

In .NET Framework ordnet die SortKey-Klasse Zeichenfolgen den entsprechenden Sortierschlüsseln zu und umgekehrt. Die Anwendung kann die 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 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 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 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 Codebeispiels 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
Imports System.Threading
Imports System.Globalization
Imports Microsoft.VisualBasic

Public Class SortKeySample
   Public Shared Sub Main()
      Dim str1 As [String] = "Apple"
      Dim str2 As [String] = "Æble"
      
      ' Sets the CurrentCulture to "da-DK".
      Dim dk As New CultureInfo("da-DK")
      Thread.CurrentThread.CurrentCulture = dk
      
      ' Creates 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)
      
      ' Compares the two sort keys and display the results.
      Dim result1 As Integer = SortKey.Compare(sc1, sc2)
      Console.WriteLine(ControlChars.Newline + "When the CurrentCulture _
         is ""da-DK""," + ControlChars.Newline + " the result of _
         comparing {0} with {1} is: {2}", str1, str2, result1)
      
      ' Sets the CurrentCulture to "en-US".
      Dim enus As New CultureInfo("en-US")
      Thread.CurrentThread.CurrentCulture = enus
      
      ' Creates 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)
      
      ' Compares the two sort keys and display the results.
      Dim result2 As Integer = SortKey.Compare(sc3, sc4)
      Console.WriteLine(ControlChars.Newline + "When the CurrentCulture _
         is ""en-US""," + ControlChars.Newline + " the result of _
         comparing {0} with {1} is: {2}", str1, str2, result2)
   End Sub
End Class

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

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

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

      // Creates 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);

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

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

      // Creates 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);

      // Compares the two sort keys and display the results.
      int result2 = SortKey.Compare(sc3, sc4);
      Console.WriteLine("\nWhen the CurrentCulture is \"en-US\",\nthe 
            result of comparing {0} with {1} is: {2}", str1, str2, 
            result2);
   }
}

Dieser Code erzeugt die folgende Ausgabe:

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