StringComparison StringComparison StringComparison StringComparison Enum

Definicja

Określa kultury, wielkości liter i regułami sortowania, który będzie używany przez niektóre przeciążenia Compare(String, String) i Equals(Object) metody.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
StringComparisonStringComparisonStringComparisonStringComparison
Atrybuty

Pola

CurrentCulture CurrentCulture CurrentCulture CurrentCulture 0

Porównywanie ciągów za pomocą reguł sortowania wrażliwość na ustawienia kulturowe i bieżącej kultury.Compare strings using culture-sensitive sort rules and the current culture.

CurrentCultureIgnoreCase CurrentCultureIgnoreCase CurrentCultureIgnoreCase CurrentCultureIgnoreCase 1

Porównywanie ciągów za pomocą reguł sortowania wrażliwość na ustawienia kulturowe, bieżącej kultury i ignoruje wielkość liter ciągów, w którą jest porównywany.Compare strings using culture-sensitive sort rules, the current culture, and ignoring the case of the strings being compared.

InvariantCulture InvariantCulture InvariantCulture InvariantCulture 2

Porównywanie ciągów za pomocą reguł sortowania wrażliwość na ustawienia kulturowe i Niezmienna kultura.Compare strings using culture-sensitive sort rules and the invariant culture.

InvariantCultureIgnoreCase InvariantCultureIgnoreCase InvariantCultureIgnoreCase InvariantCultureIgnoreCase 3

Porównywanie ciągów za pomocą reguł sortowania wrażliwość na ustawienia kulturowe, niezmienna kultura i ignoruje wielkość liter ciągów, w którą jest porównywany.Compare strings using culture-sensitive sort rules, the invariant culture, and ignoring the case of the strings being compared.

Ordinal Ordinal Ordinal Ordinal 4

Porównywanie ciągów za pomocą reguły porządkowe sortowania (binarnych).Compare strings using ordinal (binary) sort rules.

OrdinalIgnoreCase OrdinalIgnoreCase OrdinalIgnoreCase OrdinalIgnoreCase 5

Porównywanie ciągów za pomocą reguły porządkowe sortowania (plik binarny) i ignoruje wielkość liter ciągów, w którą jest porównywany.Compare strings using ordinal (binary) sort rules and ignoring the case of the strings being compared.

Przykłady

W poniższym przykładzie porównano cztery zestawy wyrazów za pomocą każdego elementu członkowskiego StringComparison wyliczenia.The following example compares four sets of words by using each member of the StringComparison enumeration. Porównania używać konwencji języka angielskiego (Stany Zjednoczone) i Sami kultur północnej (Szwecja).The comparisons use the conventions of the English (United States) and Sami, Northern (Sweden) cultures. Należy pamiętać, że ciągi "wartości" i "encyklopedii" są uważane za równoważne w kulturze en US, ale nie znajduje się w Sami 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

StringComparison Wyliczenia jest używany do określenia, czy porównania ciągów należy używać bieżącej kultury lub niezmiennej kultury, słowa lub reguły porządkowe sortowania i być uwzględniana wielkość liter lub bez uwzględniania wielkości 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łujesz metodę porównywania ciągów takich jak String.Compare, String.Equals, lub String.IndexOf, zawsze powinna wywołać przeciążenie obejmujące parametr typu StringComparison tak, aby określić typ porównania, który wykonuje 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 Using Strings.For more information, see Best Practices for Using Strings.

Operacja, która używa reguł sortowania wyrazów wykonuje porównanie zależne od kultury polegającego niektóre znaki niealfanumeryczne Unicode mogą mieć specjalnie przypisane im 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 wyrazów i Konwencji określonej kultury, łącznik ("-") może być bardzo małą wagę, przypisane do niego, aby "coop" oraz "co-OP będą" wyświetlane obok siebie w posortowanej listy.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 liczbowych (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 niezależnych od kultury.An ordinal comparison is fast but culture-insensitive. Gdy używasz reguły porządkowe sortowania do sortowania ciągów, które zaczyna się znaków Unicode (U +), ciąg U + xxxx znajduje się przed ciągu U + rrrr przypadku wartość xxxx numerycznie mniejszą 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 System.String klasy uwagi.For more information about comparisons, see the System.String class remarks. Aby uzyskać więcej informacji o kulturze, zobacz System.Globalization.CultureInfo klasy uwagi.For more information about culture, see the System.Globalization.CultureInfo class remarks. Aby uzyskać wskazówki dotyczące kiedy należy używać reguł porównania porządkowego lub wrażliwość na ustawienia kulturowe lub zasad niezmiennej kultury, zobacz najlepsze rozwiązania dotyczące Using Strings.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 wagi znaku w operacjach sortowania i porównywania systemów operacyjnych Windows, zobacz tabele wagi sortowania.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. Dla tabeli wagi sortowania dla systemów Linux i macOS, zobacz Tabela elementów domyślne sortowanie Unicode.For the sort weight table for Linux and macOS, see the Default Unicode Collation Element Table.

Dotyczy

Zobacz też