StringComparison StringComparison StringComparison StringComparison Enum

Definição

Especifica as regras de classificação, de cultura e de maiúsculas e minúsculas a serem usadas por determinadas sobrecargas dos métodos 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
Herança
StringComparisonStringComparisonStringComparisonStringComparison
Atributos

Campos

CurrentCulture CurrentCulture CurrentCulture CurrentCulture 0

Compare cadeias de caracteres usando regras de classificação sensíveis à cultura e a cultura atual.Compare strings using culture-sensitive sort rules and the current culture.

CurrentCultureIgnoreCase CurrentCultureIgnoreCase CurrentCultureIgnoreCase CurrentCultureIgnoreCase 1

Compare cadeias de caracteres usando regras de classificação sensíveis à cultura, a cultura atual e ignorando o padrão de maiúsculas e minúsculas das cadeias de caracteres que estão sendo comparadas.Compare strings using culture-sensitive sort rules, the current culture, and ignoring the case of the strings being compared.

InvariantCulture InvariantCulture InvariantCulture InvariantCulture 2

Compare cadeias de caracteres usando regras de classificação sensíveis à cultura e a cultura invariável.Compare strings using culture-sensitive sort rules and the invariant culture.

InvariantCultureIgnoreCase InvariantCultureIgnoreCase InvariantCultureIgnoreCase InvariantCultureIgnoreCase 3

Compare cadeias de caracteres usando regras de classificação sensíveis à cultura, a cultura invariável e ignorando o padrão de maiúsculas e minúsculas das cadeias de caracteres que estão sendo comparadas.Compare strings using culture-sensitive sort rules, the invariant culture, and ignoring the case of the strings being compared.

Ordinal Ordinal Ordinal Ordinal 4

Compare cadeias de caracteres usando regras de classificação ordinal (binária).Compare strings using ordinal (binary) sort rules.

OrdinalIgnoreCase OrdinalIgnoreCase OrdinalIgnoreCase OrdinalIgnoreCase 5

Compare cadeias de caracteres usando regras de classificação ordinal (binária) e ignorando o padrão de maiúsculas e minúsculas das cadeias de caracteres que estão sendo comparadas.Compare strings using ordinal (binary) sort rules and ignoring the case of the strings being compared.

Exemplos

O exemplo a seguir compara os quatro conjuntos de palavras por meio de cada membro do StringComparison enumeração.The following example compares four sets of words by using each member of the StringComparison enumeration. As comparações usam as convenções do inglês (Estados Unidos) e Sami, culturas Nothern (Suécia).The comparisons use the conventions of the English (United States) and Sami, Nothern (Sweden) cultures. Observe que as cadeias de caracteres "encyclopædia" e "enciclopédia" são consideradas equivalente na cultura en-US, mas não em Sami, Norte (Suécia) 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

Comentários

O StringComparison enumeração é usada para especificar se uma comparação de cadeia de caracteres deve usar a cultura atual ou a cultura invariável, uma palavra ou regras de classificação ordinal e ter maiusculas e minúsculas ou maiusculas de minúsculas.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 você chama um método de comparação de cadeia de caracteres, como String.Compare, String.Equals, ou String.IndexOf, você sempre deve chamar uma sobrecarga que inclui um parâmetro de tipo StringComparison para que você possa especificar o tipo de comparação que executa o método.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. Para obter mais informações, consulte Práticas recomendadas para o uso de cadeias de caracteres.For more information, see Best Practices for Using Strings.

Uma operação que usa regras de classificação de palavra executa uma comparação sensível à cultura em que determinados caracteres não alfanuméricos Unicode podem ter pesos especiais atribuídos a eles.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 regras de classificação de palavras e as convenções de uma cultura específica, o hífen ("-") pode ter um peso muito pequeno atribuído a ele, de modo que "coop" e "co-op" apareçam próximos uns dos outros em uma lista classificada.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.

Observação

.NET Core em execução apenas em sistemas Linux e macOS: O comportamento de ordenação das culturas do C e do Posix sempre diferencia maiúsculas de minúsculas porque essas culturas não usam a sequência de ordenação Unicode esperada..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. Recomendamos usar uma cultura diferente de C ou Posix para executar operações de classificação que diferenciam culturas e maiúsculas de minúsculas.We recommend that you use a culture other than C or Posix for performing culture-sensitive, case-insensitive sorting operations.

Uma operação que usa regras de classificação ordinal executa uma comparação com base no valor numérico (ponto de código Unicode) de cada Char na cadeia de caracteres.An operation that uses ordinal sort rules performs a comparison based on the numeric value (Unicode code point) of each Char in the string. Uma comparação ordinal é rápido, mas insensível à cultura.An ordinal comparison is fast but culture-insensitive. Quando você usa regras de classificação ordinal para classificar cadeias de caracteres que começam com caracteres Unicode (U +), a cadeia de caracteres U + xxxx vem antes do valor de cadeia de caracteres U + aaaa se o valor de xxxx for numericamente menor que 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.

Para obter mais informações sobre comparações, consulte o System.String comentários de classe.For more information about comparisons, see the System.String class remarks. Para obter mais informações sobre a cultura, consulte o System.Globalization.CultureInfo comentários de classe.For more information about culture, see the System.Globalization.CultureInfo class remarks. Para obter diretrizes sobre quando usar regras de comparação ordinal ou sensível à cultura ou as regras da cultura invariável, consulte práticas recomendadas para usar cadeias de caracteres.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. Para um conjunto de arquivos de texto que contêm informações sobre os pesos de caractere usado em operações de classificação e comparação para os sistemas operacionais Windows, consulte tabelas de classificação de 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. Para a tabela de peso de classificação para Linux e macOS, consulte o tabela de elemento de agrupamento de Unicode padrão.For the sort weight table for Linux and macOS, see the Default Unicode Collation Element Table.

Aplica-se a

Veja também