StringComparison Wyliczenie

Definicja

Określa kulturę, wielkość liter i reguły sortowania, które mają być używane przez niektóre przeciążenia metod Compare(String, String) i Equals(Object).Specifies the culture, case, and sort rules to be used by certain overloads of the Compare(String, String) and Equals(Object) methods.

public enum class StringComparison
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public enum StringComparison
type StringComparison = 
Public Enum StringComparison
Dziedziczenie
StringComparison
Atrybuty

Pola

CurrentCulture 0

Porównywanie ciągów przy użyciu reguł sortowania wrażliwych na kulturę i bieżącej kultury.Compare strings using culture-sensitive sort rules and the current culture.

CurrentCultureIgnoreCase 1

Porównywanie ciągów przy użyciu reguł sortowania wrażliwych na kulturę, bieżącej kultury i ignorowanie wielkości liter w porównywanych ciągach.Compare strings using culture-sensitive sort rules, the current culture, and ignoring the case of the strings being compared.

InvariantCulture 2

Porównywanie ciągów przy użyciu reguł sortowania zależnych od kultury i niezmiennej kultury.Compare strings using culture-sensitive sort rules and the invariant culture.

InvariantCultureIgnoreCase 3

Porównywanie ciągów przy użyciu reguł sortowania wrażliwych na kulturę, kultury niezmiennej i ignorowanie wielkości liter porównywanych ciągów.Compare strings using culture-sensitive sort rules, the invariant culture, and ignoring the case of the strings being compared.

Ordinal 4

Porównywanie ciągów przy użyciu liczbowych reguł sortowania (Binary).Compare strings using ordinal (binary) sort rules.

OrdinalIgnoreCase 5

Porównywanie ciągów przy użyciu porządkowej (binarnej) reguł sortowania i ignorowanie wielkości liter podczas porównywania ciągów.Compare strings using ordinal (binary) sort rules and ignoring the case of the strings being compared.

Przykłady

Poniższy przykład porównuje cztery zestawy wyrazów za pomocą każdego elementu członkowskiego wyliczenia StringComparison.The following example compares four sets of words by using each member of the StringComparison enumeration. Porównania wykorzystują konwencje angielskiej (Stany Zjednoczone) i Lapoński (Szwecja) kultur.The comparisons use the conventions of the English (United States) and Sami, Northern (Sweden) cultures. Należy zauważyć, że ciągi "Encyclopædia" i "encyklopedia" są uważane za równoważne w kulturze en-US, ale nie w kulturze kultury Północnej (Szwecja).Note that the strings "encyclopædia" and "encyclopedia" are considered equivalent in the en-US culture but not in the Sami, Northern (Sweden) culture.

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

public class Example
{
   public static void Main()
   {
      String[] cultureNames = { "en-US", "se-SE" };
      String[] strings1 = { "case",  "encyclopædia",  
                            "encyclopædia", "Archæology" };
      String[] strings2 = { "Case", "encyclopaedia", 
                            "encyclopedia" , "ARCHÆOLOGY" };
      StringComparison[] comparisons = (StringComparison[]) Enum.GetValues(typeof(StringComparison));
      
      foreach (var cultureName in cultureNames) {
         Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture(cultureName);
         Console.WriteLine("Current Culture: {0}", CultureInfo.CurrentCulture.Name);
         for (int ctr = 0; ctr <= strings1.GetUpperBound(0); ctr++) {
            foreach (var comparison in comparisons) 
               Console.WriteLine("   {0} = {1} ({2}): {3}", strings1[ctr],
                                 strings2[ctr], comparison, 
                                 String.Equals(strings1[ctr], strings2[ctr], comparison));

            Console.WriteLine();         
         }
         Console.WriteLine();
      }
   }
}
// The example displays the following output:
//    Current Culture: en-US
//       case = Case (CurrentCulture): False
//       case = Case (CurrentCultureIgnoreCase): True
//       case = Case (InvariantCulture): False
//       case = Case (InvariantCultureIgnoreCase): True
//       case = Case (Ordinal): False
//       case = Case (OrdinalIgnoreCase): True
//    
//       encyclopædia = encyclopaedia (CurrentCulture): True
//       encyclopædia = encyclopaedia (CurrentCultureIgnoreCase): True
//       encyclopædia = encyclopaedia (InvariantCulture): True
//       encyclopædia = encyclopaedia (InvariantCultureIgnoreCase): True
//       encyclopædia = encyclopaedia (Ordinal): False
//       encyclopædia = encyclopaedia (OrdinalIgnoreCase): False
//    
//       encyclopædia = encyclopedia (CurrentCulture): False
//       encyclopædia = encyclopedia (CurrentCultureIgnoreCase): False
//       encyclopædia = encyclopedia (InvariantCulture): False
//       encyclopædia = encyclopedia (InvariantCultureIgnoreCase): False
//       encyclopædia = encyclopedia (Ordinal): False
//       encyclopædia = encyclopedia (OrdinalIgnoreCase): False
//    
//       Archæology = ARCHÆOLOGY (CurrentCulture): False
//       Archæology = ARCHÆOLOGY (CurrentCultureIgnoreCase): True
//       Archæology = ARCHÆOLOGY (InvariantCulture): False
//       Archæology = ARCHÆOLOGY (InvariantCultureIgnoreCase): True
//       Archæology = ARCHÆOLOGY (Ordinal): False
//       Archæology = ARCHÆOLOGY (OrdinalIgnoreCase): True
//    
//    
//    Current Culture: se-SE
//       case = Case (CurrentCulture): False
//       case = Case (CurrentCultureIgnoreCase): True
//       case = Case (InvariantCulture): False
//       case = Case (InvariantCultureIgnoreCase): True
//       case = Case (Ordinal): False
//       case = Case (OrdinalIgnoreCase): True
//    
//       encyclopædia = encyclopaedia (CurrentCulture): False
//       encyclopædia = encyclopaedia (CurrentCultureIgnoreCase): False
//       encyclopædia = encyclopaedia (InvariantCulture): True
//       encyclopædia = encyclopaedia (InvariantCultureIgnoreCase): True
//       encyclopædia = encyclopaedia (Ordinal): False
//       encyclopædia = encyclopaedia (OrdinalIgnoreCase): False
//    
//       encyclopædia = encyclopedia (CurrentCulture): False
//       encyclopædia = encyclopedia (CurrentCultureIgnoreCase): False
//       encyclopædia = encyclopedia (InvariantCulture): False
//       encyclopædia = encyclopedia (InvariantCultureIgnoreCase): False
//       encyclopædia = encyclopedia (Ordinal): False
//       encyclopædia = encyclopedia (OrdinalIgnoreCase): False
//    
//       Archæology = ARCHÆOLOGY (CurrentCulture): False
//       Archæology = ARCHÆOLOGY (CurrentCultureIgnoreCase): True
//       Archæology = ARCHÆOLOGY (InvariantCulture): False
//       Archæology = ARCHÆOLOGY (InvariantCultureIgnoreCase): True
//       Archæology = ARCHÆOLOGY (Ordinal): False
//       Archæology = ARCHÆOLOGY (OrdinalIgnoreCase): True
Imports System.Globalization
Imports System.Threading

Module Example
   Public Sub Main()
      Dim cultureNames() As String = { "en-US", "se-SE" }
      Dim strings1() As String = { "case",  "encyclopædia",  
                                   "encyclopædia", "Archæology" }
      Dim strings2() As String = { "Case", "encyclopaedia", 
                                   "encyclopedia" , "ARCHÆOLOGY" }
      Dim comparisons() As StringComparison = CType([Enum].GetValues(GetType(StringComparison)),
                                           StringComparison())
      
      For Each cultureName In cultureNames
         Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture(cultureName)
         Console.WriteLine("Current Culture: {0}", CultureInfo.CurrentCulture.Name)
         For ctr As Integer = 0 To strings1.GetUpperBound(0)
            For Each comparison In comparisons
               Console.WriteLine("   {0} = {1} ({2}): {3}", strings1(ctr),
                                 strings2(ctr), comparison, 
                                 String.Equals(strings1(ctr), strings2(ctr), comparison))
            Next
            Console.WriteLine()         
         Next
         Console.WriteLine()
      Next
   End Sub
End Module
' The example displays the following output:
'    Current Culture: en-US
'       case = Case (CurrentCulture): False
'       case = Case (CurrentCultureIgnoreCase): True
'       case = Case (InvariantCulture): False
'       case = Case (InvariantCultureIgnoreCase): True
'       case = Case (Ordinal): False
'       case = Case (OrdinalIgnoreCase): True
'    
'       encyclopædia = encyclopaedia (CurrentCulture): True
'       encyclopædia = encyclopaedia (CurrentCultureIgnoreCase): True
'       encyclopædia = encyclopaedia (InvariantCulture): True
'       encyclopædia = encyclopaedia (InvariantCultureIgnoreCase): True
'       encyclopædia = encyclopaedia (Ordinal): False
'       encyclopædia = encyclopaedia (OrdinalIgnoreCase): False
'    
'       encyclopædia = encyclopedia (CurrentCulture): False
'       encyclopædia = encyclopedia (CurrentCultureIgnoreCase): False
'       encyclopædia = encyclopedia (InvariantCulture): False
'       encyclopædia = encyclopedia (InvariantCultureIgnoreCase): False
'       encyclopædia = encyclopedia (Ordinal): False
'       encyclopædia = encyclopedia (OrdinalIgnoreCase): False
'    
'       Archæology = ARCHÆOLOGY (CurrentCulture): False
'       Archæology = ARCHÆOLOGY (CurrentCultureIgnoreCase): True
'       Archæology = ARCHÆOLOGY (InvariantCulture): False
'       Archæology = ARCHÆOLOGY (InvariantCultureIgnoreCase): True
'       Archæology = ARCHÆOLOGY (Ordinal): False
'       Archæology = ARCHÆOLOGY (OrdinalIgnoreCase): True
'    
'    
'    Current Culture: se-SE
'       case = Case (CurrentCulture): False
'       case = Case (CurrentCultureIgnoreCase): True
'       case = Case (InvariantCulture): False
'       case = Case (InvariantCultureIgnoreCase): True
'       case = Case (Ordinal): False
'       case = Case (OrdinalIgnoreCase): True
'    
'       encyclopædia = encyclopaedia (CurrentCulture): False
'       encyclopædia = encyclopaedia (CurrentCultureIgnoreCase): False
'       encyclopædia = encyclopaedia (InvariantCulture): True
'       encyclopædia = encyclopaedia (InvariantCultureIgnoreCase): True
'       encyclopædia = encyclopaedia (Ordinal): False
'       encyclopædia = encyclopaedia (OrdinalIgnoreCase): False
'    
'       encyclopædia = encyclopedia (CurrentCulture): False
'       encyclopædia = encyclopedia (CurrentCultureIgnoreCase): False
'       encyclopædia = encyclopedia (InvariantCulture): False
'       encyclopædia = encyclopedia (InvariantCultureIgnoreCase): False
'       encyclopædia = encyclopedia (Ordinal): False
'       encyclopædia = encyclopedia (OrdinalIgnoreCase): False
'    
'       Archæology = ARCHÆOLOGY (CurrentCulture): False
'       Archæology = ARCHÆOLOGY (CurrentCultureIgnoreCase): True
'       Archæology = ARCHÆOLOGY (InvariantCulture): False
'       Archæology = ARCHÆOLOGY (InvariantCultureIgnoreCase): True
'       Archæology = ARCHÆOLOGY (Ordinal): False
'       Archæology = ARCHÆOLOGY (OrdinalIgnoreCase): True

Uwagi

Wyliczenie StringComparison służy do określenia, czy Porównywanie ciągów ma używać bieżącej kultury, czy niezmiennej kultury, reguł sortowania wyrazów i porządkowych oraz uwzględniać wielkość liter.The StringComparison enumeration is used to specify whether a string comparison should use the current culture or the invariant culture, word or ordinal sort rules, and be case-sensitive or case-insensitive.

Ważne

Gdy wywoływana jest metoda porównywania ciągów, taka jak String.Compare, String.Equalslub String.IndexOf, zawsze należy wywołać Przeciążenie, które zawiera parametr typu StringComparison, aby można było określić typ porównania wykonywanego przez metodę.When you call a string comparison method such as String.Compare, String.Equals, or String.IndexOf, you should always call an overload that includes a parameter of type StringComparison so that you can specify the type of comparison that the method performs. Aby uzyskać więcej informacji, zobacz najlepsze rozwiązania dotyczące używania ciągów.For more information, see Best Practices for Using Strings.

Operacja korzystająca z reguł sortowania wyrazów wykonuje porównanie z uwzględnieniem kultury, w którym niektóre niealfanumeryczne znaki Unicode mogą mieć przypisane specjalne wagi.An operation that uses word sort rules performs a culture-sensitive comparison wherein certain nonalphanumeric Unicode characters might have special weights assigned to them. Przy użyciu reguł sortowania programu Word i Konwencji określonych kultur, łącznik ("-") może mieć przypisaną bardzo małą wagę, tak aby "coop" i "współ-op" pojawiły się obok siebie na sortowanej liście.Using word sort rules and the conventions of a specific culture, the hyphen ("-") might have a very small weight assigned to it so that "coop" and "co-op" appear next to each other in a sorted list.

Uwaga

.NET core uruchomiony tylko w systemach Linux i macOS: Zachowanie sortowania dla języków C i Posix zawsze jest wielkość liter, ponieważ te kultur nie należy używać w oczekiwanej kolejności sortowania Unicode..NET Core running on Linux and macOS systems only: The collation behavior for the C and Posix cultures is always case-sensitive because these cultures do not use the expected Unicode collation order. Zalecamy użycie kultury innej niż C lub Posix dla operacji wrażliwych na kulturę, bez uwzględniania wielkości liter sortowania.We recommend that you use a culture other than C or Posix for performing culture-sensitive, case-insensitive sorting operations.

Operacja, która używa reguł sortowania porządkowego, wykonuje porównanie na podstawie wartości liczbowej (punkt kodowy Unicode) każdego Char w ciągu.An operation that uses ordinal sort rules performs a comparison based on the numeric value (Unicode code point) of each Char in the string. Porównanie porządkowe jest szybkie, ale nie jest uwzględniana kultura.An ordinal comparison is fast but culture-insensitive. W przypadku używania reguł sortowania porządkowego do sortowania ciągów, które zaczynają się od znaków Unicode (U +), ciąg U + XXXX jest wcześniejszy niż ciąg U + rrrr, jeśli wartość XXXX jest liczbowa mniej niż rrrr.When you use ordinal sort rules to sort strings that start with Unicode characters (U+), the string U+xxxx comes before the string U+yyyy if the value of xxxx is numerically less than yyyy.

Aby uzyskać więcej informacji na temat porównań, zobacz uwagi dotyczące klas System.String.For more information about comparisons, see the System.String class remarks. Aby uzyskać więcej informacji na temat kultury, zobacz uwagi dotyczące klas System.Globalization.CultureInfo.For more information about culture, see the System.Globalization.CultureInfo class remarks. Aby uzyskać wytyczne dotyczące sytuacji, w których należy użyć reguł porównania liczb porządkowych lub kulturowych lub reguł niezmiennej kultury, zobacz najlepsze rozwiązania dotyczące używania ciągów.For guidelines on when to use ordinal or culture-sensitive comparison rules or the rules of the invariant culture, see Best Practices for Using Strings. Aby uzyskać zestaw plików tekstowych, które zawierają informacje o wagach znaków używanych w operacjach sortowania i porównywania dla systemów operacyjnych Windows, zobacz Sortowanie tabel wagi.For a set of text files that contain information on the character weights used in sorting and comparison operations for Windows operating systems, see Sorting Weight Tables. W tabeli waga sortowania dla systemów Linux i macOS zobacz domyślną tabelę elementów sortowania w formacie Unicode.For the sort weight table for Linux and macOS, see the Default Unicode Collation Element Table.

Dotyczy

Zobacz też