Bewährte Methoden für die Verwendung von Zeichenfolgen in .NETBest Practices for Using Strings in .NET

.NET bietet umfangreiche Unterstützung für die Entwicklung von lokalisierten und globalisierten Anwendungen und erleichtert es die Konventionen der aktuellen Kultur oder einer bestimmten Kultur anwenden bei allgemeinen Vorgängen wie Sortierung und Anzeige von Zeichenfolgen..NET provides extensive support for developing localized and globalized applications, and makes it easy to apply the conventions of either the current culture or a specific culture when performing common operations such as sorting and displaying strings. Das Sortieren oder Vergleichen von Zeichenfolgen stellt jedoch nicht immer eine kulturabhängige Operation dar.But sorting or comparing strings is not always a culture-sensitive operation. Beispielsweise sollten interne Zeichenfolgen von Anwendungen i. d. R. in allen Kulturen gleich behandelt werden.For example, strings that are used internally by an application typically should be handled identically across all cultures. Wenn kulturabhängige Zeichenfolgendaten, z. B. XML-Tags, HTML-Tags, Benutzernamen, Dateipfade und Systemobjektnamen, kulturabhängig interpretiert werden, können Fehler im Anwendungscode auftreten, die Leistung kann sich verschlechtern, und in einigen Fällen kann es zu Sicherheitsproblemen kommen.When culturally independent string data, such as XML tags, HTML tags, user names, file paths, and the names of system objects, are interpreted as if they were culture-sensitive, application code can be subject to subtle bugs, poor performance, and, in some cases, security issues.

In diesem Thema untersucht die Sortierung, Vergleichsoperatoren und Schreibweise Methoden in .NET, stellt Vorschläge zum Auswählen einer geeigneten Methode für die Behandlung von Zeichenfolgen und bietet weitere Informationen zur Behandlung von Zeichenfolgen-Methoden.This topic examines the string sorting, comparison, and casing methods in .NET, presents recommendations for selecting an appropriate string-handling method, and provides additional information about string-handling methods. Er wird außerdem untersucht, wie formatierte Daten, z. B. numerische Daten und Datums-/Uhrzeitdaten, für die Anzeige und Speicherung behandelt werden.It also examines how formatted data, such as numeric data and date and time data, is handled for display and for storage.

Dieses Thema enthält folgende Abschnitte:This topic contains the following sections:

Empfehlungen zur ZeichenfolgenverwendungRecommendations for String Usage

Beachten Sie folgende grundlegende Empfehlungen zur Verwendung von Zeichenfolgen bei der Entwicklung mit .NET:When you develop with .NET, follow these simple recommendations when you use strings:

Vermeiden Sie folgende Vorgehensweisen bei der Verwendung von Zeichenfolgen:Avoid the following practices when you use strings:

  • Verwenden Sie keine Überladungen, die die Regeln für Zeichenfolgenvergleiche in Zeichenfolgenoperationen nicht explizit oder implizit angeben.Do not use overloads that do not explicitly or implicitly specify the string comparison rules for string operations.

  • Verwenden Sie keine Zeichenfolgenoperationen, die auf StringComparison.InvariantCulture basieren.Do not use string operations based on StringComparison.InvariantCulture in most cases. Eine der wenigen Ausnahmen stellt dabei die Beibehaltung von Zeichenfolgen dar, die zwar linguistisch relevant, jedoch kulturunabhängig sind.One of the few exceptions is when you are persisting linguistically meaningful but culturally agnostic data.

  • Verwenden Sie keine Überladung der String.Compare-Methode oder der CompareTo-Methode, und führen Sie eine Überprüfung mit einem Rückgabewert von 0 (null) durch, um zu bestimmten, ob zwei Zeichenfolgen übereinstimmen.Do not use an overload of the String.Compare or CompareTo method and test for a return value of zero to determine whether two strings are equal.

  • Verwenden Sie nicht kulturabhängige Formatierung, um numerische Daten oder Datums-/Uhrzeitdaten im Zeichenfolgenformat beizubehalten.Do not use culture-sensitive formatting to persist numeric data or date and time data in string form.

Zurück nach obenBack to top

Explizites Angeben von ZeichenfolgenvergleichenSpecifying String Comparisons Explicitly

Die Methoden zum Bearbeiten von Zeichenfolgen in .NET werden i.d.R. überladen.Most of the string manipulation methods in .NET are overloaded. Während einige Überladungen normalerweise Standardwerte akzeptieren, geben andere Überladungen exakt an, wie Zeichenfolgen verglichen oder bearbeitet werden sollen.Typically, one or more overloads accept default settings, whereas others accept no defaults and instead define the precise way in which strings are to be compared or manipulated. Methoden, die keine Standardwerte verwenden, enthalten i. d. R einen Parameter vom Typ StringComparison. Dabei handelt es sich um eine Enumeration, die explizit Regeln für Zeichenfolgenvergleiche anhand von Kultur und Schreibweise angibt.Most of the methods that do not rely on defaults include a parameter of type StringComparison, which is an enumeration that explicitly specifies rules for string comparison by culture and case. In der folgenden Tabelle werden die Member der StringComparison -Enumeration beschrieben.The following table describes the StringComparison enumeration members.

StringComparison-MemberStringComparison member BeschreibungDescription
CurrentCulture Führt einen Vergleich mit der aktuellen Kultur unter Beachtung der Groß- und Kleinschreibung durch.Performs a case-sensitive comparison using the current culture.
CurrentCultureIgnoreCase Führt einen Vergleich mit der aktuellen Kultur ohne Beachtung der Groß- und Kleinschreibung durch.Performs a case-insensitive comparison using the current culture.
InvariantCulture Führt einen Vergleich mit der invarianten Kultur unter Beachtung der Groß- und Kleinschreibung durch.Performs a case-sensitive comparison using the invariant culture.
InvariantCultureIgnoreCase Führt einen Vergleich mit der invarianten Kultur ohne Beachtung der Groß- und Kleinschreibung durch.Performs a case-insensitive comparison using the invariant culture.
Ordinal Führt einen Ordinalvergleich durch.Performs an ordinal comparison.
OrdinalIgnoreCase Führt einen Ordinalvergleich ohne Beachtung der Groß- und Kleinschreibung durch.Performs a case-insensitive ordinal comparison.

Die IndexOf -Methode, die den Index einer Teilzeichenfolge in einem String -Objekt zurückgibt, das einem Zeichen oder einer Zeichenfolge entspricht, weist beispielsweise neun Überladungen auf:For example, the IndexOf method, which returns the index of a substring in a String object that matches either a character or a string, has nine overloads:

Aus den folgenden Gründen wird empfohlen, eine Überladung ohne Standardwerte auszuwählen:We recommend that you select an overload that does not use default values, for the following reasons:

  • Einige Überladungen mit Standardparametern (die in der Zeichenfolgeninstanz nach einem Char suchen) führen einen Ordinalvergleich durch, während andere Überladungen (die in der Zeichenfolgeninstanz nach einer Zeichenfolge suchen) kulturabhängig sind.Some overloads with default parameters (those that search for a Char in the string instance) perform an ordinal comparison, whereas others (those that search for a string in the string instance) are culture-sensitive. Es ist nicht leicht, sich zu merken, welche Methode welchen Standardwert verwendet, und Überladungen können schnell verwechselt werden.It is difficult to remember which method uses which default value, and easy to confuse the overloads.

  • Der Zweck des Codes, der Standardwerte für Methodenaufrufe verwendet, ist nicht klar.The intent of the code that relies on default values for method calls is not clear. Im folgenden Beispiel, das auf Standardwerten beruht, ist nur schwer erkennbar, ob der Entwickler tatsächlich einen Ordinalvergleich oder einen linguistischen Vergleich von zwei Zeichenfolgen durchführen wollte oder ob ein Unterschied in der Groß-/Kleinschreibung zwischen protocol und „HTTP“ möglicherweise dazu führt, dass bei einer Prüfung auf Gleichheit falseaufrufen.In the following example, which relies on defaults, it is difficult to know whether the developer actually intended an ordinal or a linguistic comparison of two strings, or whether a case difference between protocol and "http" might cause the test for equality to return false.

    string protocol = GetProtocol(url);       
    if (String.Equals(protocol, "http")) {
       // ...Code to handle HTTP protocol.
    }
    else {
       throw new InvalidOperationException();
    }
    
    Dim protocol As String = GetProtocol(url)       
    If String.Equals(protocol, "http") Then
       ' ...Code to handle HTTP protocol.
    Else
       Throw New InvalidOperationException()
    End If   
    

Im Allgemeinen empfiehlt es sich, eine Methode aufzurufen, die keine Standardwerte verwendet, da der Zweck des Codes andernfalls möglicherweise nicht eindeutig ist.In general, we recommend that you call a method that does not rely on defaults, because it makes the intent of the code unambiguous. Dies erleichtert wiederum das Lesen, Verwalten und Debuggen des Codes.This, in turn, makes the code more readable and easier to debug and maintain. Im folgenden Beispiel wird auf die Fragen eingegangen, die sich zum vorherigen Beispiel stellen.The following example addresses the questions raised about the previous example. Es wird deutlich gemacht, dass der Ordinalvergleich verwendet wird und dass Unterschiede in der Groß- und Kleinschreibung ignoriert werden.It makes it clear that ordinal comparison is used and that differences in case are ignored.

string protocol = GetProtocol(url);       
if (String.Equals(protocol, "http", StringComparison.OrdinalIgnoreCase)) {
   // ...Code to handle HTTP protocol.
}
else {
   throw new InvalidOperationException();
}
Dim protocol As String = GetProtocol(url)       
If String.Equals(protocol, "http", StringComparison.OrdinalIgnoreCase) Then
   ' ...Code to handle HTTP protocol.
Else
   Throw New InvalidOperationException()
End If   

Zurück nach obenBack to top

Details zum ZeichenfolgenvergleichThe Details of String Comparison

Zeichenfolgenvergleiche bilden den Kern zahlreicher Operationen, die sich auf Zeichenfolgen beziehen; dies gilt insbesondere für Sortierungen und Überprüfungen auf Gleichheit.String comparison is the heart of many string-related operations, particularly sorting and testing for equality. Zeichenfolgen werden in einer bestimmten Reihenfolge sortiert: Wenn "my" in einer sortierten Zeichenfolgenliste vor "string" angezeigt wird, muss "my" bei einem Vergleich einen kleineren oder gleichen Wert wie "string" haben.Strings sort in a determined order: If "my" appears before "string" in a sorted list of strings, "my" must compare less than or equal to "string". Darüber hinaus wird beim Vergleich implizit Gleichheit definiert.Additionally, comparison implicitly defines equality. Die Vergleichsoperation gibt 0 (null) für Zeichenfolgen zurück, die als gleich betrachtet werden.The comparison operation returns zero for strings it deems equal. Dies kann so interpretiert werden, dass keine Zeichenfolge kleiner ist als die andere.A good interpretation is that neither string is less than the other. Sinnvolle Operationen mit Zeichenfolgen schließen i. d. R. mindestens eines der folgenden Verfahren ein: Vergleich mit einer anderen Zeichenfolge und Ausführen eines genau definierten Sortiervorgangs.Most meaningful operations involving strings include one or both of these procedures: comparing with another string, and executing a well-defined sort operation.

Die Überprüfung der Sortierreihenfolge zweier Zeichenfolgen oder ihre Überprüfung auf Gleichheit ergibt jedoch nicht ein einzelnes richtiges Ergebnis. Das Ergebnis ist vielmehr abhängig von den Kriterien, die dem Zeichenfolgenvergleich zugrunde liegen.However, evaluating two strings for equality or sort order does not yield a single, correct result; the outcome depends on the criteria used to compare the strings. Insbesondere können Zeichenfolgenvergleiche zu unterschiedlichen Ergebnissen führen, die Ordinalvergleiche darstellen oder auf der Schreibweise und den Sortierungskonventionen der aktuellen oder der invarianten Kultur (eine auf der englischen Sprache basierende Kultur, die nicht von einem Gebietsschema abhängig ist) basieren.In particular, string comparisons that are ordinal or that are based on the casing and sorting conventions of the current culture or the invariant culture (a locale-agnostic culture based on the English language) may produce different results.

Zeichenfolgenvergleiche mit der aktuellen KulturString Comparisons that Use the Current Culture

Ein Kriterium für Zeichenfolgenvergleiche stellt die Verwendung der Konventionen der aktuellen Kultur dar.One criterion involves using the conventions of the current culture when comparing strings. Vergleiche, die auf der aktuellen Kultur basieren, verwenden die aktuelle Kultur oder das aktuelle Gebietsschema des Threads.Comparisons that are based on the current culture use the thread's current culture or locale. Wenn die Kultur nicht vom Benutzer festgelegt wird, wird standardmäßig die Einstellung im Fenster Ländereinstellungen in der Systemsteuerung verwendet.If the culture is not set by the user, it defaults to the setting in the Regional Options window in Control Panel. Vergleiche, die auf der aktuellen Kultur basieren, sollten immer dann verwendet werden, wenn Daten linguistisch relevant sind und kulturabhängige Interaktionen von Benutzern widerspiegeln.You should always use comparisons that are based on the current culture when data is linguistically relevant, and when it reflects culture-sensitive user interaction.

Das Verhalten im Hinblick auf Vergleiche und die Groß- und Kleinschreibung in .NET ändert sich jedoch, wenn sich die Kultur ändert.However, comparison and casing behavior in .NET changes when the culture changes. Dies ist der Fall, wenn eine Anwendung auf einem Computer mit einer anderen Kultur ausgeführt wird, als der Computer, auf dem die Anwendung entwickelt wurde, oder wenn der ausführende Thread seine Kultur ändert.This happens when an application executes on a computer that has a different culture than the computer on which the application was developed, or when the executing thread changes its culture. Dieses Verhalten ist beabsichtigt, für viele Entwickler jedoch nicht offensichtlich.This behavior is intentional, but it remains non-obvious to many developers. Im folgenden Beispiel werden die Unterschiede zwischen den Sortierreihenfolgen in der englischen (amerikanisch, "en-US") und schwedischen ("sv-SE") Kultur herausgestellt.The following example illustrates differences in sort order between the U.S. English ("en-US") and Swedish ("sv-SE") cultures. Beachten Sie, dass die Wörter „ångström“, „Windows“ und „Visual Studio“ in den sortierten Zeichenfolgenarrays an unterschiedlichen Positionen angezeigt werden.Note that the words "ångström", "Windows", and "Visual Studio" appear in different positions in the sorted string arrays.

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

public class Example
{
   public static void Main()
   {
      string[] values= { "able", "ångström", "apple", "Æble", 
                         "Windows", "Visual Studio" };
      Array.Sort(values);
      DisplayArray(values);

      // Change culture to Swedish (Sweden).
      string originalCulture = CultureInfo.CurrentCulture.Name;
      Thread.CurrentThread.CurrentCulture = new CultureInfo("sv-SE");
      Array.Sort(values);
      DisplayArray(values);

      // Restore the original culture.
      Thread.CurrentThread.CurrentCulture = new CultureInfo(originalCulture);
    }
    
    private static void DisplayArray(string[] values)
    {
      Console.WriteLine("Sorting using the {0} culture:",  
                        CultureInfo.CurrentCulture.Name);
      foreach (string value in values)
         Console.WriteLine("   {0}", value);

      Console.WriteLine();
    }
}
// The example displays the following output:
//       Sorting using the en-US culture:
//          able
//          Æble
//          ångström
//          apple
//          Visual Studio
//          Windows
//       
//       Sorting using the sv-SE culture:
//          able
//          Æble
//          apple
//          Windows
//          Visual Studio
//          ångström
Imports System.Globalization
Imports System.Threading

Module Example
   Public Sub Main()
      Dim values() As String = { "able", "ångström", "apple", _
                                 "Æble", "Windows", "Visual Studio" }
      Array.Sort(values)
      DisplayArray(values)

      ' Change culture to Swedish (Sweden).
      Dim originalCulture As String = CultureInfo.CurrentCulture.Name
      Thread.CurrentThread.CurrentCulture = New CultureInfo("sv-SE")
      Array.Sort(values)
      DisplayArray(values)

      ' Restore the original culture.
      Thread.CurrentThread.CurrentCulture = New CultureInfo(originalCulture)
    End Sub
    
    Private Sub DisplayArray(values() As String)
      Console.WRiteLine("Sorting using the {0} culture:", _ 
                        CultureInfo.CurrentCulture.Name)
      For Each value As String In values
         Console.WriteLine("   {0}", value)
      Next
      Console.WriteLine()   
    End Sub
End Module
' The example displays the following output:
'       Sorting using the en-US culture:
'          able
'          Æble
'          ångström
'          apple
'          Visual Studio
'          Windows
'       
'       Sorting using the sv-SE culture:
'          able
'          Æble
'          apple
'          Windows
'          Visual Studio
'          ångström

Vergleiche mit der aktuellen Kultur, bei denen nicht zwischen Groß- und Kleinschreibung unterschieden wird, entsprechen kulturabhängigen Vergleichen, ignorieren jedoch die Schreibweise, die von der aktuellen Kultur des Threads vorgegeben wird.Case-insensitive comparisons that use the current culture are the same as culture-sensitive comparisons, except that they ignore case as dictated by the thread's current culture. Dieses Verhalten zeigt sich möglicherweise auch bei Sortierreihenfolgen.This behavior may manifest itself in sort orders as well.

Vergleiche mit der Semantik der aktuellen Kultur werden standardmäßig für folgende Methoden verwendet:Comparisons that use current culture semantics are the default for the following methods:

In jedem Fall wird empfohlen, eine Überladung mit einem StringComparison -Parameter aufzurufen, um den Zweck des Methodenaufrufs eindeutig anzugeben.In any case, we recommend that you call an overload that has a StringComparison parameter to make the intent of the method call clear.

Wenn nicht linguistische Zeichenfolgendaten linguistisch interpretiert werden, oder wenn Zeichenfolgendaten in einer bestimmten Kultur mit den Konventionen einer anderen Kultur interpretiert werden, können offensichtliche und nur schwer erkennbare Fehler auftreten.Subtle and not so subtle bugs can emerge when non-linguistic string data is interpreted linguistically, or when string data from a particular culture is interpreted using the conventions of another culture. Kanonisches Beispiel ist das Problem mit dem Zeichen "I" im Türkischen.The canonical example is the Turkish-I problem.

In beinahe allen lateinischen Alphabetarten, einschließlich des englischen (USA) Alphabets, ist das Zeichen "i" (\u0069) die Kleinschreibungsvariante des Zeichens "I" (\u0049).For nearly all Latin alphabets, including U.S. English, the character "i" (\u0069) is the lowercase version of the character "I" (\u0049). Diese Regel zur Groß- und Kleinschreibung wird von Entwicklern, die in den entsprechenden Kulturen programmieren, leicht als Standard zugrunde gelegt.This casing rule quickly becomes the default for someone programming in such a culture. Das türkische Alphabet ("tr-TR") enthält jedoch ein "I" mit einem Punkt ("İ" bzw. \u0130), welches den Großbuchstaben des Zeichens "i" darstellt.However, the Turkish ("tr-TR") alphabet includes an "I with a dot" character "İ" (\u0130), which is the capital version of "i". Ferner verfügt Türkisch auch über ein kleines "i ohne Punkt ("ı" bzw. \u0131), dessen Entsprechung als Großbuchstabe das Zeichen "I" ist.Turkish also includes a lowercase "i without a dot" character, "ı" (\u0131), which capitalizes to "I". Die Kultur Aserbaidschanisch (az-AZ) weist ein analoges Verhalten auf.This behavior occurs in the Azerbaijani ("az") culture as well.

Annahmen über die Großschreibung von "i" oder die Kleinschreibung von "I" sind daher nicht für alle Kulturen gleichermaßen gültig.Therefore, assumptions made about capitalizing "i" or lowercasing "I" are not valid among all cultures. Wenn Sie die Standardüberladungen für Zeichenfolgenvergleichsroutinen verwenden, weisen diese je nach der zugrunde liegenden Kultur Unterschiede auf.If you use the default overloads for string comparison routines, they will be subject to variance between cultures. Bei einem Vergleich nicht linguistischer Daten kann die Verwendung der Standardüberladungen zu unerwünschten Ergebnissen führen. Dies wird durch den folgenden Versuch veranschaulicht, einen Vergleich der Zeichenfolgen "file" und "FILE" ohne Beachtung der Groß- und Kleinschreibung durchzuführen.If the data to be compared is non-linguistic, using the default overloads can produce undesirable results, as the following attempt to perform a case-insensitive comparison of the strings "file" and "FILE" illustrates.

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

public class Example
{
   public static void Main()
   {
      string fileUrl = "file";
      Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
      Console.WriteLine("Culture = {0}",
                        Thread.CurrentThread.CurrentCulture.DisplayName);
      Console.WriteLine("(file == FILE) = {0}", 
                       fileUrl.StartsWith("FILE", true, null));
      Console.WriteLine();
      
      Thread.CurrentThread.CurrentCulture = new CultureInfo("tr-TR");
      Console.WriteLine("Culture = {0}",
                        Thread.CurrentThread.CurrentCulture.DisplayName);
      Console.WriteLine("(file == FILE) = {0}", 
                        fileUrl.StartsWith("FILE", true, null));
   }
}
// The example displays the following output:
//       Culture = English (United States)
//       (file == FILE) = True
//       
//       Culture = Turkish (Turkey)
//       (file == FILE) = False
Imports System.Globalization
Imports System.Threading

Module Example
   Public Sub Main()
      Dim fileUrl = "file"
      Thread.CurrentThread.CurrentCulture = New CultureInfo("en-US")
      Console.WriteLine("Culture = {0}", _
                        Thread.CurrentThread.CurrentCulture.DisplayName)
      Console.WriteLine("(file == FILE) = {0}", _ 
                       fileUrl.StartsWith("FILE", True, Nothing))
      Console.WriteLine()
      
      Thread.CurrentThread.CurrentCulture = New CultureInfo("tr-TR")
      Console.WriteLine("Culture = {0}", _
                        Thread.CurrentThread.CurrentCulture.DisplayName)
      Console.WriteLine("(file == FILE) = {0}", _ 
                        fileUrl.StartsWith("FILE", True, Nothing))
   End Sub
End Module
' The example displays the following output:
'       Culture = English (United States)
'       (file == FILE) = True
'       
'       Culture = Turkish (Turkey)
'       (file == FILE) = False

Dieser Vergleich kann signifikante Probleme verursachen, wenn die Kultur versehentlich in sicherheitsrelevanten Einstellungen verwendet wird, wie im folgenden Beispiel veranschaulicht.This comparison could cause significant problems if the culture is inadvertently used in security-sensitive settings, as in the following example. Ein Methodenaufruf wie IsFileURI("file:") gibt true zurück, wenn die aktuelle Kultur "Englisch (USA)" ist und false, wenn die aktuelle Kultur "Türkisch" ist.A method call such as IsFileURI("file:") returns true if the current culture is U.S. English, but false if the current culture is Turkish. In einem System mit der Kultur "Türkisch" wäre es daher vorstellbar, dass Sicherheitsvorkehrungen umgangen werden, die den Zugriff auf URIs blockieren, die mit "FILE:" beginnen und nicht zwischen Groß- und Kleinschreibung unterscheiden.Thus, on Turkish systems, someone could circumvent security measures that block access to case-insensitive URIs that begin with "FILE:".

public static bool IsFileURI(String path) 
{
   return path.StartsWith("FILE:", true, null);
}
Public Shared Function IsFileURI(path As String) As Boolean 
   Return path.StartsWith("FILE:", True, Nothing)
End Function

Stattdessen sollte der Code daher in diesem Fall wie im folgenden Beispiel geschrieben werden, da "file:" als nicht linguistischer und kulturunabhängiger Bezeichner interpretiert werden soll.In this case, because "file:" is meant to be interpreted as a non-linguistic, culture-insensitive identifier, the code should instead be written as shown in the following example.

public static bool IsFileURI(string path) 
{
   return path.StartsWith("FILE:", StringComparison.OrdinalIgnoreCase);
}
Public Shared Function IsFileURI(path As String) As Boolean 
    Return path.StartsWith("FILE:", StringComparison.OrdinalIgnoreCase)
End Function

OrdinalzeichenfolgenoperationenOrdinal String Operations

Der StringComparison.Ordinal-Wert oder der StringComparison.OrdinalIgnoreCase-Wert in einem Methodenaufruf kennzeichnen einen nicht linguistischen Vergleich, in dem die Funktionen von natürlichen Sprachen ignoriert werden.Specifying the StringComparison.Ordinal or StringComparison.OrdinalIgnoreCase value in a method call signifies a non-linguistic comparison in which the features of natural languages are ignored. Bei Methoden, die mit diesen StringComparison -Werten aufgerufen werden, werden für Entscheidungen bezüglich Zeichenfolgenoperation einfache Bytevergleiche anstelle von Groß- und Kleinschreibung oder nach Kultur parametrisierten Entsprechungstabellen zugrunde gelegt.Methods that are invoked with these StringComparison values base string operation decisions on simple byte comparisons instead of casing or equivalence tables that are parameterized by culture. In aller Regel ist diese Vorgehensweise am besten für die beabsichtigte Interpretation von Zeichenfolgen geeignet und macht den Code sicherer und zuverlässiger.In most cases, this approach best fits the intended interpretation of strings while making code faster and more reliable.

Ordinalvergleiche sind Zeichenfolgenvergleiche, in denen die einzelnen Bytes einer Zeichenfolge ohne linguistische Interpretation verglichen werden, z. B. entspricht "windows" nicht "Windows".Ordinal comparisons are string comparisons in which each byte of each string is compared without linguistic interpretation; for example, "windows" does not match "Windows". Dies stellt im Grunde einen Aufruf der strcmp -Funktion dar.This is essentially a call to the C runtime strcmp function. Verwenden Sie diesen Vergleich, wenn der Kontext eine exakte Entsprechung von Zeichenfolgen oder eine konservative Entsprechungsrichtlinie verlangt.Use this comparison when the context dictates that strings should be matched exactly or demands conservative matching policy. Darüber hinaus werden Ordinalvergleiche am schnellsten durchgeführt, da beim Bestimmen eines Ergebnisses keine linguistischen Regeln verwendet werden.Additionally, ordinal comparison is the fastest comparison operation because it applies no linguistic rules when determining a result.

Zeichenfolgen in .NET können eingebettete NULL-Zeichen aufweisen.Strings in .NET can contain embedded null characters. Einer der auffälligsten Unterschiede zwischen einem ordinalen und einem kulturabhängigen Vergleich (einschließlich Vergleichen, die die invariante Kultur verwenden) betrifft die Behandlung von eingebetteten NULL-Zeichen in einer Zeichenfolge.One of the clearest differences between ordinal and culture-sensitive comparison (including comparisons that use the invariant culture) concerns the handling of embedded null characters in a string. Wenn Sie die String.Compare-Methode und die String.Equals-Methode verwenden, um kulturabhängige Vergleiche (einschließlich Vergleichen, die die invariante Kultur verwenden) durchzuführen, werden diese Zeichen ignoriert.These characters are ignored when you use the String.Compare and String.Equals methods to perform culture-sensitive comparisons (including comparisons that use the invariant culture). Bei kulturabhängigen Vergleichen können Zeichenfolgen mit eingebetteten NULL-Zeichen daher als gleichwertig mit Zeichenfolgen ohne diese Zeichen angesehen werden.As a result, in culture-sensitive comparisons, strings that contain embedded null characters can be considered equal to strings that do not.

Wichtig

Auch wenn eingebettete NULL-Zeichen von Zeichenfolgenvergleichsmethoden ignoriert werden, ist dies bei Zeichenfolgensuchmethoden wie String.Contains, String.EndsWith, String.IndexOf, String.LastIndexOf und String.StartsWith nicht der Fall.Although string comparison methods disregard embedded null characters, string search methods such as String.Contains, String.EndsWith, String.IndexOf, String.LastIndexOf, and String.StartsWith do not.

Im folgenden Beispiel wird ein kulturabhängiger Vergleich der Zeichenfolge "Aa" mit einer ähnlichen Zeichenfolge durchgeführt, die mehrere eingebettete NULL-Zeichen zwischen "A" und "a" enthält, und es wird angezeigt, inwieweit die beiden Zeichenfolgen als gleich betrachtet werden.The following example performs a culture-sensitive comparison of the string "Aa" with a similar string that contains several embedded null characters between "A" and "a", and shows how the two strings are considered equal.

using System;

public class Example
{
   public static void Main()
   {
      string str1 = "Aa";
      string str2 = "A" + new String('\u0000', 3) + "a";
      Console.WriteLine("Comparing '{0}' ({1}) and '{2}' ({3}):", 
                        str1, ShowBytes(str1), str2, ShowBytes(str2));
      Console.WriteLine("   With String.Compare:");
      Console.WriteLine("      Current Culture: {0}", 
                        String.Compare(str1, str2, StringComparison.CurrentCulture));
      Console.WriteLine("      Invariant Culture: {0}", 
                        String.Compare(str1, str2, StringComparison.InvariantCulture));

      Console.WriteLine("   With String.Equals:");
      Console.WriteLine("      Current Culture: {0}", 
                        String.Equals(str1, str2, StringComparison.CurrentCulture));
      Console.WriteLine("      Invariant Culture: {0}", 
                        String.Equals(str1, str2, StringComparison.InvariantCulture));
   }
   
   private static string ShowBytes(string str)
   {
      string hexString = String.Empty;
      for (int ctr = 0; ctr < str.Length; ctr++)
      {
         string result = String.Empty;
         result = Convert.ToInt32(str[ctr]).ToString("X4");
         result = " " + result.Substring(0,2) + " " + result.Substring(2, 2);
         hexString += result;
      }
      return hexString.Trim();
   }
}
// The example displays the following output:
//    Comparing 'Aa' (00 41 00 61) and 'A   a' (00 41 00 00 00 00 00 00 00 61):
//       With String.Compare:
//          Current Culture: 0
//          Invariant Culture: 0
//       With String.Equals:
//          Current Culture: True
//          Invariant Culture: True
Module Example
   Public Sub Main()
      Dim str1 As String = "Aa"
      Dim str2 As String = "A" + New String(Convert.ToChar(0), 3) + "a"
      Console.WriteLine("Comparing '{0}' ({1}) and '{2}' ({3}):", _
                        str1, ShowBytes(str1), str2, ShowBytes(str2))
      Console.WriteLine("   With String.Compare:")
      Console.WriteLine("      Current Culture: {0}", _
                        String.Compare(str1, str2, StringComparison.CurrentCulture))
      Console.WriteLine("      Invariant Culture: {0}", _
                        String.Compare(str1, str2, StringComparison.InvariantCulture))

      Console.WriteLine("   With String.Equals:")
      Console.WriteLine("      Current Culture: {0}", _
                        String.Equals(str1, str2, StringComparison.CurrentCulture))
      Console.WriteLine("      Invariant Culture: {0}", _
                        String.Equals(str1, str2, StringComparison.InvariantCulture))
   End Sub
   
   Private Function ShowBytes(str As String) As String
      Dim hexString As String = String.Empty
      For ctr As Integer = 0 To str.Length - 1
         Dim result As String = String.Empty
         result = Convert.ToInt32(str.Chars(ctr)).ToString("X4")
         result = " " + result.Substring(0,2) + " " + result.Substring(2, 2)
         hexString += result
      Next
      Return hexString.Trim()
   End Function
End Module

Bei einem Ordinalvergleich werden die Zeichenfolgen jedoch nicht als gleich betrachtet, wie das folgende Beispiel zeigt.However, the strings are not considered equal when you use ordinal comparison, as the following example shows.

Console.WriteLine("Comparing '{0}' ({1}) and '{2}' ({3}):", 
                  str1, ShowBytes(str1), str2, ShowBytes(str2));
Console.WriteLine("   With String.Compare:");
Console.WriteLine("      Ordinal: {0}", 
                  String.Compare(str1, str2, StringComparison.Ordinal));

Console.WriteLine("   With String.Equals:");
Console.WriteLine("      Ordinal: {0}", 
                  String.Equals(str1, str2, StringComparison.Ordinal));
// The example displays the following output:
//    Comparing 'Aa' (00 41 00 61) and 'A   a' (00 41 00 00 00 00 00 00 00 61):
//       With String.Compare:
//          Ordinal: 97
//       With String.Equals:
//          Ordinal: False
Console.WriteLine("Comparing '{0}' ({1}) and '{2}' ({3}):", _
                  str1, ShowBytes(str1), str2, ShowBytes(str2))
Console.WriteLine("   With String.Compare:")
Console.WriteLine("      Ordinal: {0}", _
                  String.Compare(str1, str2, StringComparison.Ordinal))

Console.WriteLine("   With String.Equals:")
Console.WriteLine("      Ordinal: {0}", _
                  String.Equals(str1, str2, StringComparison.Ordinal))
' The example displays the following output:
'    Comparing 'Aa' (00 41 00 61) and 'A   a' (00 41 00 00 00 00 00 00 00 61):
'       With String.Compare:
'          Ordinal: 97
'       With String.Equals:
'          Ordinal: False

Ordinalvergleiche, bei denen die Groß- und Kleinschreibung nicht beachtet wird, folgen als nächster konservativer Ansatz.Case-insensitive ordinal comparisons are the next most conservative approach. Diese Vergleichen ignorieren die Groß- und Kleinschreibung i. d. R.; "windows" entspricht dann beispielsweise "Windows".These comparisons ignore most casing; for example, "windows" matches "Windows". Im Hinblick auf ASCII-Zeichen entspricht diese Richtlinie StringComparison.Ordinal, mit der Ausnahme, dass die üblichen ASCII-Schreibungsregeln nicht beachtet wird.When dealing with ASCII characters, this policy is equivalent to StringComparison.Ordinal, except that it ignores the usual ASCII casing. Ein beliebiges Zeichen in A, Z entspricht daher dem zugehörigen Zeichen in a,z.Therefore, any character in A, Z matches the corresponding character in a,z. Die Groß- und Kleinschreibung außerhalb des ASCII-Bereichs verwendet die Tabellen der invarianten Kultur.Casing outside the ASCII range uses the invariant culture's tables. Daher entspricht der folgende VergleichTherefore, the following comparison:

String.Compare(strA, strB, StringComparison.OrdinalIgnoreCase);
String.Compare(strA, strB, StringComparison.OrdinalIgnoreCase)

dem nachstehenden Vergleich (ist jedoch schneller):is equivalent to (but faster than) this comparison:

String.Compare(strA.ToUpperInvariant(), strB.ToUpperInvariant(), 
               StringComparison.Ordinal);
String.Compare(strA.ToUpperInvariant(), strB.ToUpperInvariant(), 
               StringComparison.Ordinal)

Diese Vergleiche werden immer noch sehr schnell durchgeführt.These comparisons are still very fast.

Hinweis

Das Zeichenfolgenverhalten von Dateisystem, Registrierungsschlüsseln und -werten sowie Umgebungsvariablen wird am besten von StringComparison.OrdinalIgnoreCase dargestellt.The string behavior of the file system, registry keys and values, and environment variables is best represented by StringComparison.OrdinalIgnoreCase.

StringComparison.Ordinal und StringComparison.OrdinalIgnoreCase verwenden die Binärwerte direkt und eignen sich am besten für Vergleiche.Both StringComparison.Ordinal and StringComparison.OrdinalIgnoreCase use the binary values directly, and are best suited for matching. Wenn Sie nicht sicher über die Vergleichseinstellungen sind, verwenden Sie einen dieser beiden Werte.When you are not sure about your comparison settings, use one of these two values. Da hier jedoch ein Vergleich auf Byteebene durchgeführt wird, erfolgt die Sortierung nicht anhand einer linguistischen Sortierreihenfolge (analog zu einem englischen Wörterbuch), sondern anhand einer binären Rangfolge.However, because they perform a byte-by-byte comparison, they do not sort by a linguistic sort order (like an English dictionary) but by a binary sort order. Die Ergebnisse erscheinen Benutzern möglicherweise in den meisten Kontexten seltsam.The results may look odd in most contexts if displayed to users.

Ordinalemantik ist die Standardeinstellung für String.Equals-Überladungen, die kein StringComparison-Argument (einschließlich des Gleichheitsoperators) enthalten.Ordinal semantics are the default for String.Equals overloads that do not include a StringComparison argument (including the equality operator). In jedem Fall wird empfohlen, eine Überladung mit einem StringComparison -Parameter aufzurufen.In any case, we recommend that you call an overload that has a StringComparison parameter.

Zeichenfolgenoperationen mit der invarianten KulturString Operations that Use the Invariant Culture

Vergleiche mit der invarianten Kultur verwenden die CompareInfo-Eigenschaft, die von der statischen CultureInfo.InvariantCulture-Eigenschaft zurückgegeben wird.Comparisons with the invariant culture use the CompareInfo property returned by the static CultureInfo.InvariantCulture property. Dieses Verhalten ist in allen Systemen gleich: Zeichen außerhalb des Bereichs werden in Zeichen übersetzt, von denen angenommen wird, dass es sich um die invarianten Entsprechungen handelt.This behavior is the same on all systems; it translates any characters outside its range into what it believes are equivalent invariant characters. Diese Richtlinie kann für das kulturübergreifende Beibehalten eines Satzes von Zeichenfolgenverhalten hilfreich sein, führt jedoch oftmals zu unerwarteten Ergebnissen.This policy can be useful for maintaining one set of string behavior across cultures, but it often provides unexpected results.

Vergleiche mit der invarianten Kultur, bei denen nicht zwischen Groß- und Kleinschreibung unterschieden wird, verwenden für Vergleichsinformationen ebenfalls die statische CompareInfo-Eigenschaft, die von der statischen CultureInfo.InvariantCulture-Eigenschaft zurückgegeben wird.Case-insensitive comparisons with the invariant culture use the static CompareInfo property returned by the static CultureInfo.InvariantCulture property for comparison information as well. Alle Unterschiede bezüglich der Groß- und Kleinschreibung in den übersetzten Zeichen werden ignoriert.Any case differences among these translated characters are ignored.

Vergleiche, die StringComparison.InvariantCulture verwenden, und StringComparison.Ordinal, werden analog für ASCII-Zeichenfolgen ausgeführt.Comparisons that use StringComparison.InvariantCulture and StringComparison.Ordinal work identically on ASCII strings. StringComparison.InvariantCulture trifft jedoch linguistische Entscheidungen, die sich möglicherweise nicht für Zeichenfolgen eignen, die als Bytesatz interpretiert werden müssen.However, StringComparison.InvariantCulture makes linguistic decisions that might not be appropriate for strings that have to be interpreted as a set of bytes. Das CultureInfo.InvariantCulture.CompareInfo -Objekt führt dazu, dass die Compare -Methode bestimmte Zeichensätze als äquivalent interpretiert.The CultureInfo.InvariantCulture.CompareInfo object makes the Compare method interpret certain sets of characters as equivalent. Die folgende Äquivalenz ist beispielsweise in der invarianten Kultur gültig:For example, the following equivalence is valid under the invariant culture:

InvariantCulture: a + ̊ = åInvariantCulture: a + ̊ = å

Der LATEINISCHE KLEINBUCHSTABE "a" (\u0061) wird, wenn er sich neben dem KOMBINIERENDEN ÜBERGESETZTEN RING "+ " ̊" (\u030a) befindet, als LATEINISCHER KLEINBUCHSTABE MIT ÜBERGESETZTEM RING interpretiert "å" (\u00e5).The LATIN SMALL LETTER A character "a" (\u0061), when it is next to the COMBINING RING ABOVE character "+ " ̊" (\u030a), is interpreted as the LATIN SMALL LETTER A WITH RING ABOVE character "å" (\u00e5). Wie das folgende Beispiel zeigt, unterscheidet sich dieses Verhalten vom Ordinalvergleich.As the following example shows, this behavior differs from ordinal comparison.

string separated = "\u0061\u030a";
string combined = "\u00e5";
      
Console.WriteLine("Equal sort weight of {0} and {1} using InvariantCulture: {2}",
                  separated, combined, 
                  String.Compare(separated, combined, 
                                 StringComparison.InvariantCulture) == 0);

Console.WriteLine("Equal sort weight of {0} and {1} using Ordinal: {2}",
                  separated, combined,
                  String.Compare(separated, combined, 
                                 StringComparison.Ordinal) == 0);
// The example displays the following output:
//    Equal sort weight of a° and å using InvariantCulture: True
//    Equal sort weight of a° and å using Ordinal: False      
Dim separated As String = ChrW(&h61) + ChrW(&h30a)
Dim combined As String = ChrW(&he5)
      
Console.WriteLine("Equal sort weight of {0} and {1} using InvariantCulture: {2}", _
                  separated, combined, _
                  String.Compare(separated, combined, _ 
                                 StringComparison.InvariantCulture) = 0)

Console.WriteLine("Equal sort weight of {0} and {1} using Ordinal: {2}", _
                  separated, combined, _
                  String.Compare(separated, combined, _
                                 StringComparison.Ordinal) = 0)
' The example displays the following output:
'    Equal sort weight of a° and å using InvariantCulture: True
'    Equal sort weight of a° and å using Ordinal: False

Wenn sie Dateinamen, Cookies oder andere Elemente interpretieren, die eine Kombination wie "å" enthalten können, bieten Ordinalvergleiche immer noch das transparenteste und am besten geeignete Verhalten an.When interpreting file names, cookies, or anything else where a combination such as "å" can appear, ordinal comparisons still offer the most transparent and fitting behavior.

Insgesamt verfügt die invariante Kultur nur über sehr wenige Eigenschaften, die für einen Vergleich hilfreich sind.On balance, the invariant culture has very few properties that make it useful for comparison. Sie führt Vergleiche mit linguistischer Relevanz durch und kann daher keine vollständige symbolische Äquivalenz garantieren, eignet sich jedoch nicht unbedingt für die Anzeige in einer beliebigen Kultur.It does comparison in a linguistically relevant manner, which prevents it from guaranteeing full symbolic equivalence, but it is not the choice for display in any culture. Einer der wenigen Gründe, StringComparison.InvariantCulture für Vergleiche zu verwenden, besteht darin, sortierte Daten für die kulturübergreifend einheitliche Anzeige beizubehalten.One of the few reasons to use StringComparison.InvariantCulture for comparison is to persist ordered data for a cross-culturally identical display. Wenn beispielsweise eine große Datendatei mit einer Liste sortierter Anzeigebezeichner einer Anwendung angehört, würde das Hinzufügen von Elementen zu dieser Liste einen Einfügevorgang mit invarianter Sortierung erfordern.For example, if a large data file that contains a list of sorted identifiers for display accompanies an application, adding to this list would require an insertion with invariant-style sorting.

Zurück nach obenBack to top

Auswählen eines StringComparison-Members für den MethodenaufrufChoosing a StringComparison Member for Your Method Call

In der folgenden Tabelle wird die Zuordnung von semantischem Zeichenfolgenkontext zu einem StringComparison -Enumerationsmember beschrieben.The following table outlines the mapping from semantic string context to a StringComparison enumeration member.

DatenData VerhaltenBehavior System.StringComparison-EntsprechungCorresponding System.StringComparison

Wertvalue
Interne Bezeichner, die die Groß- und Kleinschreibung beachten.Case-sensitive internal identifiers.

Bezeichner in Standards wie XML und HTTP, die die Groß- und Kleinschreibung beachten.Case-sensitive identifiers in standards such as XML and HTTP.

Sicherheitsbezogene Einstellungen, die die Groß- und Kleinschreibung beachten.Case-sensitive security-related settings.
Ein nicht linguistischer Bezeichner mit exakt übereinstimmenden Bytes.A non-linguistic identifier, where bytes match exactly. Ordinal
Interne Bezeichner, die die Groß- und Kleinschreibung nicht beachten.Case-insensitive internal identifiers.

Bezeichner in Standards wie XML und HTTP, die die Groß- und Kleinschreibung nicht beachten.Case-insensitive identifiers in standards such as XML and HTTP.

Dateipfade.File paths.

Registrierungsschlüssel und -werte.Registry keys and values.

Umgebungsvariablen.Environment variables.

Ressourcenbezeichner (z. B. Handlenamen).Resource identifiers (for example, handle names).

Sicherheitsbezogene Einstellungen, die die Groß- und Kleinschreibung nicht beachten.Case-insensitive security-related settings.
Ein nicht linguistischer Bezeichner, bei dem die Groß- und Kleinschreibung keine Rolle spielt; insbesondere für Daten, die in den meisten Systemdiensten von Windows gespeichert werden.A non-linguistic identifier, where case is irrelevant; especially data stored in most Windows system services. OrdinalIgnoreCase
Einige beibehaltene, linguistisch relevante Daten.Some persisted, linguistically relevant data.

Anzeige von linguistischen Daten, die eine feste Sortierreihenfolge erfordern.Display of linguistic data that requires a fixed sort order.
Kulturunabhängige Daten, die dennoch linguistisch relevant sind.Culturally agnostic data that still is linguistically relevant. InvariantCulture

- oder --or-

InvariantCultureIgnoreCase
Daten, die dem Benutzer angezeigt werden.Data displayed to the user.

Die meisten Benutzereingaben.Most user input.
Daten, die lokale linguistische Regeln erfordern.Data that requires local linguistic customs. CurrentCulture

- oder --or-

CurrentCultureIgnoreCase

Zurück nach obenBack to top

Allgemeine Methoden zum Zeichenfolgenvergleich in .NETCommon String Comparison Methods in .NET

In den folgenden Abschnitten werden die Methoden beschrieben, die am häufigsten für Zeichenfolgenvergleiche verwendet werden.The following sections describe the methods that are most commonly used for string comparison.

String.CompareString.Compare

Standardinterpretation: StringComparison.CurrentCulture.Default interpretation: StringComparison.CurrentCulture.

Der Aufruf dieser Methode stellt die zentrale Operation für Zeichenfolgeninterpretation dar. Aus diesem Grund sollten alle Instanzen von Methodenaufrufen untersucht werden, um zu bestimmen, ob Zeichenfolgen anhand der aktuellen Kultur oder unabhängig von der Kultur (symbolisch) interpretiert werden sollen.As the operation most central to string interpretation, all instances of these method calls should be examined to determine whether strings should be interpreted according to the current culture, or dissociated from the culture (symbolically). Üblicherweise handelt es sich um eine symbolische Interpretation, und stattdessen sollte ein StringComparison.Ordinal-Vergleich verwendet werden.Typically, it is the latter, and a StringComparison.Ordinal comparison should be used instead.

Die System.Globalization.CompareInfo-Klasse, die von der CultureInfo.CompareInfo-Eigenschaft zurückgegeben wird, enthält auch eine Compare-Methode, die zahlreiche Vergleichsoptionen (ordinal, ohne Leerraumzeichen, ohne Zeichen vom Typ Kana usw.) über die CompareOptions-Flagenumeration zur Verfügung stellt.The System.Globalization.CompareInfo class, which is returned by the CultureInfo.CompareInfo property, also includes a Compare method that provides a large number of matching options (ordinal, ignoring white space, ignoring kana type, and so on) by means of the CompareOptions flag enumeration.

String.CompareToString.CompareTo

Standardinterpretation: StringComparison.CurrentCulture.Default interpretation: StringComparison.CurrentCulture.

Diese Methode bietet derzeit keine Überladung an, die einen StringComparison -Typ angibt.This method does not currently offer an overload that specifies a StringComparison type. Diese Methode kann normalerweise in das empfohlene String.Compare(String, String, StringComparison)-Format konvertiert werden.It is usually possible to convert this method to the recommended String.Compare(String, String, StringComparison) form.

Diese Methode wird von Typen implementiert, die die IComparable - und die IComparable<T> -Schnittstelle implementieren.Types that implement the IComparable and IComparable<T> interfaces implement this method. Da der StringComparison -Parameter hier nicht verfügbar ist, ermöglichen implementierende Typen oftmals das Angeben eines StringComparer im entsprechenden Konstruktor.Because it does not offer the option of a StringComparison parameter, implementing types often let the user specify a StringComparer in their constructor. Im folgenden Beispiel wird eine FileName -Klasse definiert, deren Klassenkonstruktor einen StringComparer -Parameter enthält.The following example defines a FileName class whose class constructor includes a StringComparer parameter. Dieses StringComparer -Objekt wird dann in der FileName.CompareTo -Methode verwendet.This StringComparer object is then used in the FileName.CompareTo method.

using System;

public class FileName : IComparable
{
   string fname;
   StringComparer comparer; 
   
   public FileName(string name, StringComparer comparer)
   {
      if (String.IsNullOrEmpty(name))
         throw new ArgumentNullException("name");

      this.fname = name;
      
      if (comparer != null)
         this.comparer = comparer;
      else
         this.comparer = StringComparer.OrdinalIgnoreCase;
   }

   public string Name
   {
      get { return fname; }
   }
   
   public int CompareTo(object obj)
   {
      if (obj == null) return 1;

      if (! (obj is FileName))
         return comparer.Compare(this.fname, obj.ToString());
      else
         return comparer.Compare(this.fname, ((FileName) obj).Name);
   }
}
Public Class FileName : Implements IComparable
   Dim fname As String
   Dim comparer As StringComparer 
   
   Public Sub New(name As String, comparer As StringComparer)
      If String.IsNullOrEmpty(name) Then
         Throw New ArgumentNullException("name")
      End If

      Me.fname = name
      
      If comparer IsNot Nothing Then
         Me.comparer = comparer
      Else
         Me.comparer = StringComparer.OrdinalIgnoreCase
      End If      
   End Sub

   Public ReadOnly Property Name As String
      Get
         Return fname
      End Get   
   End Property
   
   Public Function CompareTo(obj As Object) As Integer _
          Implements IComparable.CompareTo
      If obj Is Nothing Then Return 1

      If Not TypeOf obj Is FileName Then
         obj = obj.ToString()
      Else
         obj = CType(obj, FileName).Name
      End If         
      Return comparer.Compare(Me.fname, obj)
   End Function
End Class

String.EqualsString.Equals

Standardinterpretation: StringComparison.Ordinal.Default interpretation: StringComparison.Ordinal.

Mit der String -Klasse können Sie eine Überprüfung auf Gleichheit durchführen, indem Sie die Überladungen der statischen Equals -Methode oder der entsprechenden Instanzenmethode aufrufen, oder indem Sie den statischen Gleichheitsoperator verwenden.The String class lets you test for equality by calling either the static or instance Equals method overloads, or by using the static equality operator. Die Überladungen und der Operator verwenden standardmäßig einen Ordinalvergleich .The overloads and operator use ordinal comparison by default. Unabhängig davon wird jedoch empfohlen, eine Überladung aufrufen, die den StringComparison -Typ explizit angibt; dies gilt auch, wenn Sie einen Ordinalvergleich ausführen möchten. Auf diese Weise können bestimmte Zeichenfolgeninterpretationen leichter in Code gefunden werden.However, we still recommend that you call an overload that explicitly specifies the StringComparison type even if you want to perform an ordinal comparison; this makes it easier to search code for a certain string interpretation.

String.ToUpper und String.ToLowerString.ToUpper and String.ToLower

Standardinterpretation: StringComparison.CurrentCulture.Default interpretation: StringComparison.CurrentCulture.

Diese Methoden sollten mit besonderer Sorgfalt verwendet werden, da das Erzwingen der Groß- oder Kleinschreibung einer Zeichenfolge oftmals unabhängig von der Schreibweise als kleine Normalisierung für Zeichenfolgenvergleiche verwendet wird.You should be careful when you use these methods, because forcing a string to a uppercase or lowercase is often used as a small normalization for comparing strings regardless of case. Wenn dies der Fall ist, sollten Sie einen Vergleich ohne Beachtung der Groß- und Kleinschreibung in Erwägung ziehen.If so, consider using a case-insensitive comparison.

Die String.ToUpperInvariant-Methode und die String.ToLowerInvariant-Methode sind ebenfalls verfügbar.The String.ToUpperInvariant and String.ToLowerInvariant methods are also available. ToUpperInvariant wird standardmäßig zur Normalisierung der Schreibweise verwendet.ToUpperInvariant is the standard way to normalize case. Das Verhalten von Vergleichen mit StringComparison.OrdinalIgnoreCase setzt sich aus zwei Aufrufen zusammen: einem Aufruf von ToUpperInvariant für beide Zeichenfolgenargumente und einem Vergleich mithilfe von StringComparison.Ordinal.Comparisons made using StringComparison.OrdinalIgnoreCase are behaviorally the composition of two calls: calling ToUpperInvariant on both string arguments, and doing a comparison using StringComparison.Ordinal.

Überladungen sind auch für die Konvertierung in Groß- und Kleinschreibung in einer bestimmten Kultur verfügbar. Dazu wird ein CultureInfo -Objekt übergeben, das die Kultur für die Methode darstellt.Overloads are also available for converting to uppercase and lowercase in a specific culture, by passing a CultureInfo object that represents that culture to the method.

Char.ToUpper und Char.ToLowerChar.ToUpper and Char.ToLower

Standardinterpretation: StringComparison.CurrentCulture.Default interpretation: StringComparison.CurrentCulture.

Diese Methoden funktionieren ähnliche wie die String.ToUpper-Methode und die String.ToLower-Methode, die im vorherigen Abschnitt beschrieben werden.These methods work similarly to the String.ToUpper and String.ToLower methods described in the previous section.

String.StartsWith und String.EndsWithString.StartsWith and String.EndsWith

Standardinterpretation: StringComparison.CurrentCulture.Default interpretation: StringComparison.CurrentCulture.

Standardmäßig führen beide Methoden einen kulturabhängigen Vergleich durch.By default, both of these methods perform a culture-sensitive comparison.

String.IndexOf und String.LastIndexOfString.IndexOf and String.LastIndexOf

Standardinterpretation: StringComparison.CurrentCulture.Default interpretation: StringComparison.CurrentCulture.

Die Durchführung von Vergleichen durch die Standardüberladungen dieser Methoden ist nicht konsistent.There is a lack of consistency in how the default overloads of these methods perform comparisons. Alle String.IndexOf- und String.LastIndexOf-Methoden mit einem Char-Parameter führen einen Ordinalvergleich durch. Die String.IndexOf- und die String.LastIndexOf-Standardmethode mit einem String-Parameter führen dagegen einen kulturabhängigen Vergleich durch.All String.IndexOf and String.LastIndexOf methods that include a Char parameter perform an ordinal comparison, but the default String.IndexOf and String.LastIndexOf methods that include a String parameter perform a culture-sensitive comparison.

Wenn Sie die String.IndexOf(String)-Methode oder die String.LastIndexOf(String)-Methode aufrufen und eine Zeichenfolge übergeben, die in der aktuellen Instanz gesucht werden soll, empfiehlt es sich, eine Überladung aufrufen, die den StringComparison-Typ explizit angibt.If you call the String.IndexOf(String) or String.LastIndexOf(String) method and pass it a string to locate in the current instance, we recommend that you call an overload that explicitly specifies the StringComparison type. Mit den Überladungen, die ein Char -Argument enthalten, können Sie keinen StringComparison -Typ angeben.The overloads that include a Char argument do not allow you to specify a StringComparison type.

Zurück nach obenBack to top

Methoden für den indirekten ZeichenfolgenvergleichMethods that Perform String Comparison Indirectly

Einige Methoden, die keine Zeichenfolgenmethoden darstellen und deren zentrale Operation ein Zeichenfolgenvergleich ist, verwenden den StringComparer -Typ.Some non-string methods that have string comparison as a central operation use the StringComparer type. Die StringComparer-Klasse enthält sechs statische Eigenschaften, die StringComparer-Instanzen zurückgeben, deren StringComparer.Compare-Methoden folgende Arten von Zeichenfolgenvergleichen durchführen:The StringComparer class includes six static properties that return StringComparer instances whose StringComparer.Compare methods perform the following types of string comparisons:

Array.Sort und Array.BinarySearchArray.Sort and Array.BinarySearch

Standardinterpretation: StringComparison.CurrentCulture.Default interpretation: StringComparison.CurrentCulture.

Wenn Sie Daten in einer Auflistung speichern oder beibehaltene Daten aus einer Datei oder einer Datenbank in eine Auflistung lesen, können die Invarianten in der Auflistung durch einen Wechsel der aktuellen Kultur ungültig werden.When you store any data in a collection, or read persisted data from a file or database into a collection, switching the current culture can invalidate the invariants in the collection. Die Array.BinarySearch-Methode geht davon aus, dass die Elemente im zu durchsuchenden Array bereits sortiert wurden.The Array.BinarySearch method assumes that the elements in the array to be searched are already sorted. Um die einzelnen Zeichenfolgenelemente im Array zu sortieren, ruft die Array.Sort-Methode die String.Compare-Methode auf.To sort any string element in the array, the Array.Sort method calls the String.Compare method to order individual elements. Kulturabhängige Vergleich bergen ein gewisses Risiko, falls sich die Kultur zwischen dem Zeitpunkt der Sortierung des Arrays und dem Durchsuchen des Inhalts ändert.Using a culture-sensitive comparer can be dangerous if the culture changes between the time that the array is sorted and its contents are searched. Im folgenden Code beispielsweise wird das Speichern und Abrufen für den Comparer ausgeführt, der implizit von der Thread.CurrentThread.CurrentCulture -Eigenschaft zurückgegeben wird.For example, in the following code, storage and retrieval operate on the comparer that is provided implicitly by the Thread.CurrentThread.CurrentCulture property. Wenn sich die Kultur zwischen dem Aufruf von StoreNames und dem Aufruf von DoesNameExistmöglicherweise ändert, kann bei der binären Suche ein Fehler auftreten; dies gilt insbesondere, wenn der Arrayinhalt zwischen den beiden Methodenaufrufen beibehalten wird.If the culture can change between the calls to StoreNames and DoesNameExist, and especially if the array contents are persisted somewhere between the two method calls, the binary search may fail.

// Incorrect.
string []storedNames;

public void StoreNames(string [] names)
{
   int index = 0;
   storedNames = new string[names.Length];

   foreach (string name in names)
   {
      this.storedNames[index++] = name;
   }

   Array.Sort(names); // Line A.
}

public bool DoesNameExist(string name)
{
   return (Array.BinarySearch(this.storedNames, name) >= 0);  // Line B.
}
' Incorrect.
Dim storedNames() As String

Public Sub StoreNames(names() As String)
   Dim index As Integer = 0
   ReDim storedNames(names.Length - 1)
   
   For Each name As String In names
      Me.storedNames(index) = name
      index+= 1
   Next
   
   Array.Sort(names)          ' Line A.
End Sub

Public Function DoesNameExist(name As String) As Boolean
   Return Array.BinarySearch(Me.storedNames, name) >= 0      ' Line B.
End Function

Eine empfohlene Variante wird im folgenden Beispiel angezeigt, in dem die gleiche (kulturunabhängige) Ordinalvergleichsmethode verwendet wird, um das Array zu sortieren und zu durchsuchen.A recommended variation appears in the following example, which uses the same ordinal (culture-insensitive) comparison method both to sort and to search the array. Der Änderungscode wird in den zwei Beispielen in den Zeilen mit der Bezeichnung Line A und Line B angezeigt.The change code is reflected in the lines labeled Line A and Line B in the two examples.

// Correct.
string []storedNames;

public void StoreNames(string [] names)
{
   int index = 0;
   storedNames = new string[names.Length];

   foreach (string name in names)
   {
      this.storedNames[index++] = name;
   }

   Array.Sort(names, StringComparer.Ordinal);  // Line A.
}

public bool DoesNameExist(string name)
{
   return (Array.BinarySearch(this.storedNames, name, StringComparer.Ordinal) >= 0);  // Line B.
}
' Correct.
Dim storedNames() As String

Public Sub StoreNames(names() As String)
   Dim index As Integer = 0
   ReDim storedNames(names.Length - 1)
   
   For Each name As String In names
      Me.storedNames(index) = name
      index+= 1
   Next
   
   Array.Sort(names, StringComparer.Ordinal)           ' Line A.
End Sub

Public Function DoesNameExist(name As String) As Boolean
   Return Array.BinarySearch(Me.storedNames, name, StringComparer.Ordinal) >= 0      ' Line B.
End Function

Wenn diese Daten beibehalten und zwischen Kulturen verschoben werden, und wenn eine Sortierung verwendet wird, um die Daten für den Benutzer anzuzeigen, können Sie StringComparison.InvariantCulture verwenden, da durch die linguistische Verarbeitung eine bessere Benutzerausgabe erzielt wird und Änderungen der Kultur keine Auswirkungen haben.If this data is persisted and moved across cultures, and sorting is used to present this data to the user, you might consider using StringComparison.InvariantCulture, which operates linguistically for better user output but is unaffected by changes in culture. Im folgenden Beispiel werden die zwei vorherigen Beispiele geändert, um die invariante Kultur zum Sortieren und Durchsuchen des Arrays zu verwenden.The following example modifies the two previous examples to use the invariant culture for sorting and searching the array.

// Correct.
string []storedNames;

public void StoreNames(string [] names)
{
   int index = 0;
   storedNames = new string[names.Length];

   foreach (string name in names)
   {
      this.storedNames[index++] = name;
   }

   Array.Sort(names, StringComparer.InvariantCulture);  // Line A.
}

public bool DoesNameExist(string name)
{
   return (Array.BinarySearch(this.storedNames, name, StringComparer.InvariantCulture) >= 0);  // Line B.
}
' Correct.
Dim storedNames() As String

Public Sub StoreNames(names() As String)
   Dim index As Integer = 0
   ReDim storedNames(names.Length - 1)
   
   For Each name As String In names
      Me.storedNames(index) = name
      index+= 1
   Next
   
   Array.Sort(names, StringComparer.InvariantCulture)           ' Line A.
End Sub

Public Function DoesNameExist(name As String) As Boolean
   Return Array.BinarySearch(Me.storedNames, name, StringComparer.InvariantCulture) >= 0      ' Line B.
End Function

Beispiel für Auflistungen: Hashtable-KonstruktorCollections Example: Hashtable Constructor

Auch beim Hashen von Zeichenfolgen können sich, je nachdem, wie die Zeichenfolgen verglichen werden, Auswirkungen auf die Operation ergeben.Hashing strings provides a second example of an operation that is affected by the way in which strings are compared.

Im folgenden Beispiel wird ein Hashtable-Objekt instanziiert, indem das StringComparer-Objekt übergeben wird, das von der StringComparer.OrdinalIgnoreCase-Eigenschaft zurückgegeben wird.The following example instantiates a Hashtable object by passing it the StringComparer object that is returned by the StringComparer.OrdinalIgnoreCase property. Da eine Klasse StringComparer , die von StringComparer abgeleitet wird, die IEqualityComparer -Schnittstelle implementiert, wird die GetHashCode -Methode verwendet, um den Hashcode von Zeichenfolgen in der Hashtabelle zu berechnen.Because a class StringComparer that is derived from StringComparer implements the IEqualityComparer interface, its GetHashCode method is used to compute the hash code of strings in the hash table.

const int initialTableCapacity = 100;
Hashtable h;

public void PopulateFileTable(string directory)
{
   h = new Hashtable(initialTableCapacity, 
                     StringComparer.OrdinalIgnoreCase);
         
   foreach (string file in Directory.GetFiles(directory))
         h.Add(file, File.GetCreationTime(file));
}

public void PrintCreationTime(string targetFile)
{
   Object dt = h[targetFile];
   if (dt != null)
   {
      Console.WriteLine("File {0} was created at time {1}.",
         targetFile, 
         (DateTime) dt);
   }
   else
   {
      Console.WriteLine("File {0} does not exist.", targetFile);
   }
}
Const initialTableCapacity As Integer = 100
Dim h As Hashtable

Public Sub PopulateFileTable(dir As String)
   h = New Hashtable(initialTableCapacity, _
                     StringComparer.OrdinalIgnoreCase)
                     
   For Each filename As String In Directory.GetFiles(dir)
      h.Add(filename, File.GetCreationTime(filename))
   Next                        
End Sub

Public Sub PrintCreationTime(targetFile As String)
   Dim dt As Object = h(targetFile)
   If dt IsNot Nothing Then
      Console.WriteLine("File {0} was created at {1}.", _
         targetFile, _
         CDate(dt))
   Else
      Console.WriteLine("File {0} does not exist.", targetFile)
   End If
End Sub  

Zurück nach obenBack to top

Anzeigen und Beibehalten von formatierten DatenDisplaying and Persisting Formatted Data

Wenn Sie Benutzern Daten anzeigen, die keine Zeichenfolge sind, z. B. Zahlen sowie Datumsangaben und Zeitangaben, formatieren Sie diese den Kultureinstellungen des Benutzers entsprechend.When you display non-string data such as numbers and dates and times to users, format them by using the user's cultural settings. Standardmäßig verwenden die String.Format-Methode und die ToString-Methoden der numerischen Typen und der Datums- und Uhrzeittypen die aktuelle Threadkultur für Formatierungsvorgänge.By default, the String.Format method and the ToString methods of the numeric types and the date and time types use the current thread culture for formatting operations. Um explizit anzugeben, dass die Formatierungsmethode die aktuelle Kultur verwenden soll, können Sie eine Überladung einer Formatierungsmethode mit einem provider-Parameter, z. B. String.Format(IFormatProvider, String, Object[]) oder DateTime.ToString(IFormatProvider), aufrufen und der Methode die CultureInfo.CurrentCulture-Eigenschaft übergeben.To explicitly specify that the formatting method should use the current culture, you can call an overload of a formatting method that has a provider parameter, such as String.Format(IFormatProvider, String, Object[]) or DateTime.ToString(IFormatProvider), and pass it the CultureInfo.CurrentCulture property.

Sie können Daten, die keine Zeichenfolge sind, entweder als Binärdaten oder als formatierte Daten beibehalten.You can persist non-string data either as binary data or as formatted data. Wenn Sie möchten, dass sie als formatierte Daten gespeichert werden, sollten Sie eine Überladung einer Formatierungsmethode aufrufen, die einen provider-Parameter einschließt, und dabei die CultureInfo.InvariantCulture-Eigenschaft übergeben.If you choose to save it as formatted data, you should call a formatting method overload that includes a provider parameter and pass it the CultureInfo.InvariantCulture property. Die invariante Kultur stellt ein konsistentes Format für formatierte Daten bereit, das unabhängig von der Kultur und dem Computers ist.The invariant culture provides a consistent format for formatted data that is independent of culture and machine. Im Gegensatz dazu bringt das Beibehalten von Daten, die mit anderen Kulturen als der invarianten Kultur formatiert werden, einige Einschränkungen mit sich:In contrast, persisting data that is formatted by using cultures other than the invariant culture has a number of limitations:

  • Die Daten sind wahrscheinlich unbrauchbar, wenn sie auf einem System mit einer andere Kultur abgerufen werden oder wenn der Benutzer des aktuellen Systems die aktuelle Kultur ändert und versucht, die Daten abzurufen.The data is likely to be unusable if it is retrieved on a system that has a different culture, or if the user of the current system changes the current culture and tries to retrieve the data.

  • Die Eigenschaften einer Kultur auf einem bestimmten Computer können von den Standardwerten abweichen.The properties of a culture on a specific computer can differ from standard values. Ein Benutzer kann kulturabhängige Anzeigeeinstellungen jederzeit anpassen.At any time, a user can customize culture-sensitive display settings. Aufgrund dessen können formatierte Daten, die in einem System gespeichert sind, möglicherweise nicht mehr gelesen werden, wenn der Benutzer die Kultureinstellungen anpasst.Because of this, formatted data that is saved on a system may not be readable after the user customizes cultural settings. Die computerübergreifende Portabilität von formatierten Daten wird wahrscheinlich sogar noch eingeschränkter.The portability of formatted data across computers is likely to be even more limited.

  • Internationale, regionale oder nationale Standards, die die Formatierung von Zahlen oder Datumsangaben und Uhrzeiten regeln, ändern sich mit der Zeit, und diese Änderungen werden in Windows-Betriebssystemupdates integriert.International, regional, or national standards that govern the formatting of numbers or dates and times change over time, and these changes are incorporated into Windows operating system updates. Wenn sich die Formatierungskonventionen ändern, können Daten, die anhand früherer Konventionen formatiert wurden, möglicherweise nicht mehr gelesen werden.When formatting conventions change, data that was formatted by using the previous conventions may become unreadable.

Das folgende Beispiel veranschaulicht die eingeschränkte Portabilität, die sich aus der Verwendung von kulturabhängiger Formatierung zum Beibehalten von Daten ergibt.The following example illustrates the limited portability that results from using culture-sensitive formatting to persist data. In dem Beispiel wird ein Array von Daten- und Uhrzeitwerten in einer Datei gespeichert.The example saves an array of date and time values to a file. Diese werden anhand der Konventionen der Kultur Englisch (USA) formatiert.These are formatted by using the conventions of the English (United States) culture. Nachdem die aktuelle Threadkultur der Anwendung in Französisch (Schweiz) geändert wird, versucht die Anwendung, die gespeicherten Werte mithilfe der Formatierungskonventionen der aktuellen Kultur zu lesen.After the application changes the current thread culture to French (Switzerland), it tries to read the saved values by using the formatting conventions of the current culture. Der Versuch, zwei der Datenelemente zu lesen, löst eine FormatException -Ausnahme aus, und das Array von Datumsangaben enthält nun zwei falsche Elemente, die MinValueentsprechen.The attempt to read two of the data items throws a FormatException exception, and the array of dates now contains two incorrect elements that are equal to MinValue.

using System;
using System.Globalization;
using System.IO;
using System.Text;
using System.Threading;

public class Example
{
   private static string filename = @".\dates.dat";

   public static void Main()
   {
      DateTime[] dates = { new DateTime(1758, 5, 6, 21, 26, 0), 
                           new DateTime(1818, 5, 5, 7, 19, 0), 
                           new DateTime(1870, 4, 22, 23, 54, 0),  
                           new DateTime(1890, 9, 8, 6, 47, 0), 
                           new DateTime(1905, 2, 18, 15, 12, 0) }; 
      // Write the data to a file using the current culture.
      WriteData(dates);
      // Change the current culture.
      Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("fr-CH");
      // Read the data using the current culture.
      DateTime[] newDates = ReadData();
      foreach (var newDate in newDates)
         Console.WriteLine(newDate.ToString("g"));
   }
   
   private static void WriteData(DateTime[] dates) 
   {
      StreamWriter sw = new StreamWriter(filename, false, Encoding.UTF8);    
      for (int ctr = 0; ctr < dates.Length; ctr++) {
         sw.Write("{0}", dates[ctr].ToString("g", CultureInfo.CurrentCulture));
         if (ctr < dates.Length - 1) sw.Write("|");   
      }      
      sw.Close();
   }
   
   private static DateTime[] ReadData() 
   {
      bool exceptionOccurred = false;
           
      // Read file contents as a single string, then split it.
      StreamReader sr = new StreamReader(filename, Encoding.UTF8);
      string output = sr.ReadToEnd();
      sr.Close();   

      string[] values = output.Split( new char[] { '|' } );
      DateTime[] newDates = new DateTime[values.Length]; 
      for (int ctr = 0; ctr < values.Length; ctr++) {
         try {
            newDates[ctr] = DateTime.Parse(values[ctr], CultureInfo.CurrentCulture);
         }
         catch (FormatException) {
            Console.WriteLine("Failed to parse {0}", values[ctr]);
            exceptionOccurred = true;
         }
      }      
      if (exceptionOccurred) Console.WriteLine();
      return newDates;
   }
}
// The example displays the following output:
//       Failed to parse 4/22/1870 11:54 PM
//       Failed to parse 2/18/1905 3:12 PM
//       
//       05.06.1758 21:26
//       05.05.1818 07:19
//       01.01.0001 00:00
//       09.08.1890 06:47
//       01.01.0001 00:00
//       01.01.0001 00:00
Imports System.Globalization
Imports System.IO
Imports System.Text
Imports System.Threading

Module Example
   Private filename As String = ".\dates.dat"
   
   Public Sub Main()
      Dim dates() As Date = { #5/6/1758 9:26PM#, #5/5/1818 7:19AM#, _ 
                              #4/22/1870 11:54PM#, #9/8/1890 6:47AM#, _ 
                              #2/18/1905 3:12PM# }
      ' Write the data to a file using the current culture.
      WriteData(dates)
      ' Change the current culture.
      Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("fr-CH")
      ' Read the data using the current culture.
      Dim newDates() As Date = ReadData()
      For Each newDate In newDates
         Console.WriteLine(newDate.ToString("g"))
      Next
   End Sub
   
   Private Sub WriteData(dates() As Date)
      Dim sw As New StreamWriter(filename, False, Encoding.Utf8)    
      For ctr As Integer = 0 To dates.Length - 1
         sw.Write("{0}", dates(ctr).ToString("g", CultureInfo.CurrentCulture))
         If ctr < dates.Length - 1 Then sw.Write("|")   
      Next      
      sw.Close()
   End Sub
   
   Private Function ReadData() As Date()
      Dim exceptionOccurred As Boolean = False
           
      ' Read file contents as a single string, then split it.
      Dim sr As New StreamReader(filename, Encoding.Utf8)
      Dim output As String = sr.ReadToEnd()
      sr.Close()   

      Dim values() As String = output.Split( {"|"c } )
      Dim newDates(values.Length - 1) As Date 
      For ctr As Integer = 0 To values.Length - 1
         Try
            newDates(ctr) = DateTime.Parse(values(ctr), CultureInfo.CurrentCulture)
         Catch e As FormatException
            Console.WriteLine("Failed to parse {0}", values(ctr))
            exceptionOccurred = True
         End Try
      Next      
      If exceptionOccurred Then Console.WriteLine()
      Return newDates
   End Function
End Module
' The example displays the following output:
'       Failed to parse 4/22/1870 11:54 PM
'       Failed to parse 2/18/1905 3:12 PM
'       
'       05.06.1758 21:26
'       05.05.1818 07:19
'       01.01.0001 00:00
'       09.08.1890 06:47
'       01.01.0001 00:00
'       01.01.0001 00:00
'

Wenn Sie jedoch die CultureInfo.CurrentCulture-Eigenschaft mit CultureInfo.InvariantCulture ersetzen in den Aufrufen von DateTime.ToString(String, IFormatProvider) und DateTime.Parse(String, IFormatProvider), werden die beibehaltenen Datums- und Uhrzeitdaten erfolgreich wiederhergestellt, wie die folgende Ausgabe zeigt.However, if you replace the CultureInfo.CurrentCulture property with CultureInfo.InvariantCulture in the calls to DateTime.ToString(String, IFormatProvider) and DateTime.Parse(String, IFormatProvider), the persisted date and time data is successfully restored, as the following output shows.

06.05.1758 21:26  
05.05.1818 07:19  
22.04.1870 23:54  
08.09.1890 06:47  
18.02.1905 15:12  

Siehe auchSee Also

Bearbeiten von ZeichenfolgenManipulating Strings