StringComparison Enumeráció

Definíció

Névtér:

System

Szerelvények:

netstandard.dll, System.Runtime.dll

Forrás:

StringComparison.cs

Meghatározza azokat a kulturális, eseti és rendezési szabályokat, amelyeket a metódusok és Compare(String, String) metódusok Equals(Object) bizonyos túlterhelései használnak.

public enum class StringComparison

public enum StringComparison

type StringComparison = 

Public Enum StringComparison

Öröklődés

Object

ValueType

Enum

StringComparison

Mezők

Name	Érték	Description
CurrentCulture	0	Hasonlítsa össze a sztringeket a kultúraérzékeny rendezési szabályok és az aktuális kultúra használatával.
CurrentCultureIgnoreCase	1	Hasonlítsa össze a sztringeket kulturális szempontból érzékeny rendezési szabályokkal, az aktuális kultúrával, és figyelmen kívül hagyja az összehasonlítandó sztringek esetét.
InvariantCulture	2	Hasonlítsa össze a sztringeket a kultúraérzékeny rendezési szabályok és az invariáns kultúra használatával.
InvariantCultureIgnoreCase	3	Hasonlítsa össze a sztringeket kulturális szempontból érzékeny rendezési szabályokkal, az invariáns kultúrával, és figyelmen kívül hagyja az összehasonlítandó sztringek esetét.
Ordinal	4	Sztringek összehasonlítása sorszámos (bináris) rendezési szabályok használatával.
OrdinalIgnoreCase	5	Hasonlítsa össze a sztringeket sorszámos (bináris) rendezési szabályokkal, és figyelmen kívül hagyja az összehasonlítandó sztringek esetét.

Példák

Az alábbi példa három sztringkészletet hasonlít össze az StringComparison enumerálás minden egyes tagjával. Az összehasonlítások az angol (Egyesült Államok), thai (Thaiföld) és a török (Türkiye) kultúrák konvenciói. Vegye figyelembe, hogy az "a" és az "a-" sztringek egyenértékűnek tekinthetők a "th-TH" kultúrában, a többi kultúrában azonban nem, míg az "i" és a "İ" egyenértékűnek minősül a "tr-TR" kultúrában, ha az esetet figyelmen kívül hagyja, de a többi kultúrában nem.

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

public class Example3
{
    public static void Main()
    {
        String[] cultureNames = { "en-US", "th-TH", "tr-TR" };
        String[] strings1 = { "a", "i", "case", };
        String[] strings2 = { "a-", "\u0130", "Case" };
        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
//       a = a- (CurrentCulture): False
//       a = a- (CurrentCultureIgnoreCase): False
//       a = a- (InvariantCulture): False
//       a = a- (InvariantCultureIgnoreCase): False
//       a = a- (Ordinal): False
//       a = a- (OrdinalIgnoreCase): False
//
//       i = İ (CurrentCulture): False
//       i = İ (CurrentCultureIgnoreCase): False
//       i = İ (InvariantCulture): False
//       i = İ (InvariantCultureIgnoreCase): False
//       i = İ (Ordinal): False
//       i = İ (OrdinalIgnoreCase): False
//
//       case = Case (CurrentCulture): False
//       case = Case (CurrentCultureIgnoreCase): True
//       case = Case (InvariantCulture): False
//       case = Case (InvariantCultureIgnoreCase): True
//       case = Case (Ordinal): False
//       case = Case (OrdinalIgnoreCase): True
//
//
//    Current Culture: th-TH
//       a = a- (CurrentCulture): True
//       a = a- (CurrentCultureIgnoreCase): True
//       a = a- (InvariantCulture): False
//       a = a- (InvariantCultureIgnoreCase): False
//       a = a- (Ordinal): False
//       a = a- (OrdinalIgnoreCase): False
//
//       i = İ (CurrentCulture): False
//       i = İ (CurrentCultureIgnoreCase): False
//       i = İ (InvariantCulture): False
//       i = İ (InvariantCultureIgnoreCase): False
//       i = İ (Ordinal): False
//       i = İ (OrdinalIgnoreCase): False
//
//       case = Case (CurrentCulture): False
//       case = Case (CurrentCultureIgnoreCase): True
//       case = Case (InvariantCulture): False
//       case = Case (InvariantCultureIgnoreCase): True
//       case = Case (Ordinal): False
//       case = Case (OrdinalIgnoreCase): True
//
//
//    Current Culture: tr-TR
//       a = a- (CurrentCulture): False
//       a = a- (CurrentCultureIgnoreCase): False
//       a = a- (InvariantCulture): False
//       a = a- (InvariantCultureIgnoreCase): False
//       a = a- (Ordinal): False
//       a = a- (OrdinalIgnoreCase): False
//
//       i = İ (CurrentCulture): False
//       i = İ (CurrentCultureIgnoreCase): True
//       i = İ (InvariantCulture): False
//       i = İ (InvariantCultureIgnoreCase): False
//       i = İ (Ordinal): False
//       i = İ (OrdinalIgnoreCase): False
//
//       case = Case (CurrentCulture): False
//       case = Case (CurrentCultureIgnoreCase): True
//       case = Case (InvariantCulture): False
//       case = Case (InvariantCultureIgnoreCase): True
//       case = Case (Ordinal): False
//       case = Case (OrdinalIgnoreCase): True

open System
open System.Globalization
open System.Threading

let cultureNames = 
    [| "en-US"; "se-SE" |]
let strings1 = 
    [| "case"; "encyclopædia" 
       "encyclopædia"; "Archæology" |]
let strings2 = 
    [| "Case"; "encyclopaedia" 
       "encyclopedia"; "ARCHÆOLOGY" |]
let comparisons = 
    Enum.GetValues typeof<StringComparison> :?> StringComparison[]

for cultureName in cultureNames do
    Thread.CurrentThread.CurrentCulture <- CultureInfo.CreateSpecificCulture cultureName
    printfn $"Current Culture: {CultureInfo.CurrentCulture.Name}"
    for i = 0 to strings1.GetUpperBound 0 do
        for comparison in comparisons do
            printfn $"   {strings1[i]} = {strings2[i]} ({comparison}): {String.Equals(strings1[i], strings2[i], comparison)}"
        printfn ""         
    printfn ""
// 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

Megjegyzések

Az StringComparison enumerálás azt határozza meg, hogy a sztring-összehasonlítás az aktuális kultúrát vagy az invariáns kultúrát, a szó- vagy a rendezési szabályokat használja-e, és hogy a kis- és nagybetűk megkülönböztethetők-e.

Important

Ha sztring-összehasonlító metódust hív meg, például String.Compare, String.Equalsvagy String.IndexOf, mindig olyan túlterhelést kell hívnia, amely egy típusparamétert StringComparison tartalmaz, így megadhatja a metódus által végrehajtott összehasonlítás típusát. További információ: Ajánlott eljárások sztringek használatához.

A szavak rendezési szabályait használó műveletek kultúraérzékeny összehasonlítást végeznek, amelyben bizonyos nonalphanumerikus Unicode-karakterekhez speciális súlyok tartozhatnak. A szavak rendezési szabályainak és egy adott kultúra konvencióinak használatával a kötőjel ("-") nagyon kis súlyú lehet ahhoz, hogy a "coop" és a "co-op" egymás mellett jelenjenek meg egy rendezett listában.

Note

Csak Linux és macOS rendszereken futó .NET Core: A C- és Posix-kultúrák rendezési viselkedése mindig megkülönbözteti a kis- és nagybetűket, mivel ezek a kultúrák nem a megszokott Unicode rendezési sorrendet használják. Azt javasoljuk, hogy a C vagy a Posixtól eltérő kultúrát használjon a kultúraérzékeny, kis- és nagybetűkre nem érzékeny rendezési műveletek végrehajtásához.

A rendezési szabályokat használó műveletek a sztring egyes Char számértékeinek (Unicode-kódpontjai) alapján végeznek összehasonlítást. Az ordinális összehasonlítás gyors, de a kultúra érzéketlen. Ha rendezési szabályokkal rendezi a Unicode-karakterekkel (U+) kezdődő sztringeket, az U+xxxx sztring az U+yyyy sztring elé kerül, ha az xxxx értéke numerikusan kisebb, mint y.

Az összehasonlításokkal kapcsolatos további információkért tekintse meg az System.String osztály megjegyzéseit. A kultúrával kapcsolatos további információkért tekintse meg az System.Globalization.CultureInfo osztály megjegyzéseit. A szabály- és kultúrafüggő összehasonlító szabályok vagy az invariáns kultúra szabályainak használatáról a sztringek használatának ajánlott eljárásai című témakörben olvashat. A Windows operációs rendszerek rendezési és összehasonlító műveleteihez használt karaktervastagságokra vonatkozó információkat tartalmazó szövegfájlokért lásd: Súlytáblák rendezése. A Linux és macOS rendszerekhez készült rendezési súlytáblázatot az Alapértelmezett Unicode rendezési elem táblában tekintheti meg.

Lásd még

• String
• Compare(String, String)
• Compare(String, String)
• CompareOrdinal(String, String)
• InvariantCulture