StringComparison Enumerazione

Definizione

Specifica le impostazioni cultura, la distinzione tra maiuscole e minuscole e le regole di ordinamento che devono essere usate da determinati overload dei metodi Compare(String, String) e 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
Ereditarietà
StringComparison
Attributi

Campi

CurrentCulture 0

Le stringhe vengono confrontate usando regole di ordinamento dipendenti dalle impostazioni cultura e le impostazioni cultura correnti.Compare strings using culture-sensitive sort rules and the current culture.

CurrentCultureIgnoreCase 1

Le stringhe vengono confrontate usando regole di ordinamento dipendenti dalle impostazioni cultura e le impostazioni cultura correnti e ignorando la distinzione tra maiuscole e minuscole nelle stringhe da confrontare.Compare strings using culture-sensitive sort rules, the current culture, and ignoring the case of the strings being compared.

InvariantCulture 2

Le stringhe vengono confrontate usando regole di ordinamento dipendenti dalle impostazioni cultura e le impostazioni cultura per la lingua inglese.Compare strings using culture-sensitive sort rules and the invariant culture.

InvariantCultureIgnoreCase 3

Le stringhe vengono confrontate usando regole di ordinamento dipendenti dalle impostazioni cultura e le impostazioni cultura per la lingua inglese e ignorando la distinzione tra maiuscole e minuscole nelle stringhe da confrontare.Compare strings using culture-sensitive sort rules, the invariant culture, and ignoring the case of the strings being compared.

Ordinal 4

Le stringhe vengono confrontate usando regole di ordinamento ordinali (binarie).Compare strings using ordinal (binary) sort rules.

OrdinalIgnoreCase 5

Le stringhe vengono confrontate usando regole di ordinamento ordinali (binarie) e ignorando la distinzione tra maiuscole e minuscole nelle stringhe da confrontare.Compare strings using ordinal (binary) sort rules and ignoring the case of the strings being compared.

Esempi

L'esempio seguente confronta i quattro set di parole con ogni membro del StringComparison enumerazione.The following example compares four sets of words by using each member of the StringComparison enumeration. I confronti di usano le convenzioni della lingua inglese (Stati Uniti) e Sami settentrionale (Svezia) le impostazioni cultura.The comparisons use the conventions of the English (United States) and Sami, Northern (Sweden) cultures. Si noti che le stringhe "encyclopædia" e "Enciclopedia" sono considerati equivalenti nelle impostazioni cultura en-US, ma non in Sami settentrionale (Svezia) delle impostazioni cultura.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

Commenti

Il StringComparison enumerazione viene utilizzata per specificare se un confronto tra stringhe deve usare le impostazioni cultura correnti o le impostazioni cultura invarianti, una parola o le regole di ordinamento per ordinale ed essere distinzione maiuscole/minuscole o maiuscole e minuscole.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.

Importante

Quando si chiama un metodo di confronto tra stringhe, ad esempio String.Compare, String.Equals, o String.IndexOf, è sempre necessario chiamare un overload che include un parametro di tipo StringComparison in modo che sia possibile specificare il tipo di confronto che non viene eseguita.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. Per altre informazioni, vedere Best Practices for Using Strings (Procedure consigliate per l'uso di stringhe).For more information, see Best Practices for Using Strings.

Un'operazione che utilizza le regole di ordinamento di word esegue un confronto con distinzione delle impostazioni cultura in cui determinati caratteri Unicode non alfanumerici potrebbero essere assegnata a loro.An operation that uses word sort rules performs a culture-sensitive comparison wherein certain nonalphanumeric Unicode characters might have special weights assigned to them. Usando le regole di ordinamento di word e le convenzioni delle impostazioni cultura specifiche, il trattino ("-") potrebbe avere una valenza ridotta a esso in modo che "co-op" e "coop" vengono visualizzati uno accanto a altro in un elenco ordinato.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.

Nota

.NET core in esecuzione solo in sistemi Linux e macOS: Il comportamento delle regole di confronto per le impostazioni cultura C e Posix prevede sempre la distinzione maiuscole/minuscole perché queste impostazioni cultura non usano l'ordine delle regole di confronto Unicode previsto..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. È consigliabile usare impostazioni cultura diverse da C o Posix per l'esecuzione di operazioni di ordinamento dipendenti dalle impostazioni cultura e senza distinzione tra maiuscole e minuscole.We recommend that you use a culture other than C or Posix for performing culture-sensitive, case-insensitive sorting operations.

Un'operazione che utilizza le regole di ordinamento per ordinale esegue un confronto in base al valore numerico (punto di codice Unicode) della ognuno Char nella stringa.An operation that uses ordinal sort rules performs a comparison based on the numeric value (Unicode code point) of each Char in the string. Un confronto ordinale è veloce ma indipendente dalle impostazioni cultura.An ordinal comparison is fast but culture-insensitive. Quando si utilizzano regole di ordinamento per ordinale per ordinare le stringhe che iniziano con caratteri Unicode (U +), lo stringa U+10000 xxxx precede lo stringa U + aaaa se il valore di xxxx è minore di yyyy.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.

Per altre informazioni sui confronti, vedere il System.String commenti relativi alla classe.For more information about comparisons, see the System.String class remarks. Per altre informazioni sulle impostazioni cultura, vedere il System.Globalization.CultureInfo commenti relativi alla classe.For more information about culture, see the System.Globalization.CultureInfo class remarks. Per indicazioni su quando usare le regole di confronto ordinale o distinzione delle impostazioni cultura o le regole della lingua inglese, vedere Best Practices for 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. Per un set di file di testo che contengono informazioni sul peso carattere utilizzato nelle operazioni di ordinamento e confronto per i sistemi operativi Windows, vedere l'ordinamento delle tabelle di peso.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. Per la tabella di peso di ordinamento per Linux e macOS, vedere la predefinito nella tabella delle regole di confronto Unicode elemento.For the sort weight table for Linux and macOS, see the Default Unicode Collation Element Table.

Si applica a

Vedi anche