StringComparison StringComparison StringComparison StringComparison Enum

Definición

Especifica las reglas de referencia cultural, uso de mayúsculas y minúsculas, y ordenación que usarán determinadas sobrecargas de los métodos Compare(String, String) y 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
Herencia
StringComparisonStringComparisonStringComparisonStringComparison
Atributos

Campos

CurrentCulture CurrentCulture CurrentCulture CurrentCulture 0

Compara cadenas mediante las reglas de ordenación de la referencia cultural y la referencia cultural actual.Compare strings using culture-sensitive sort rules and the current culture.

CurrentCultureIgnoreCase CurrentCultureIgnoreCase CurrentCultureIgnoreCase CurrentCultureIgnoreCase 1

Compara cadenas mediante las reglas de ordenación de la referencia cultural y la referencia cultural actual, e ignora el uso de mayúsculas y minúsculas de las cadenas que se comparan.Compare strings using culture-sensitive sort rules, the current culture, and ignoring the case of the strings being compared.

InvariantCulture InvariantCulture InvariantCulture InvariantCulture 2

Compara cadenas mediante las reglas de ordenación de la referencia cultural y la referencia invariable.Compare strings using culture-sensitive sort rules and the invariant culture.

InvariantCultureIgnoreCase InvariantCultureIgnoreCase InvariantCultureIgnoreCase InvariantCultureIgnoreCase 3

Compara cadenas mediante las reglas de ordenación de la referencia cultural y la referencia cultural invariable, e ignora el uso de mayúsculas y minúsculas de las cadenas que se comparan.Compare strings using culture-sensitive sort rules, the invariant culture, and ignoring the case of the strings being compared.

Ordinal Ordinal Ordinal Ordinal 4

Compara cadenas mediante las reglas de ordenación ordinal (binaria).Compare strings using ordinal (binary) sort rules.

OrdinalIgnoreCase OrdinalIgnoreCase OrdinalIgnoreCase OrdinalIgnoreCase 5

Compara cadenas mediante las reglas de ordenación ordinal (binaria) e ignora el uso de mayúsculas y minúsculas de las cadenas que se comparan.Compare strings using ordinal (binary) sort rules and ignoring the case of the strings being compared.

Ejemplos

En el ejemplo siguiente se comparan cuatro conjuntos de palabras mediante el uso de cada miembro de la StringComparison enumeración.The following example compares four sets of words by using each member of the StringComparison enumeration. Las comparaciones usan las convenciones del inglés (Estados Unidos) y Sami septentrional (Suecia) las referencias culturales.The comparisons use the conventions of the English (United States) and Sami, Northern (Sweden) cultures. Tenga en cuenta que las cadenas "encyclopædia" y "enciclopedia" se consideran equivalentes en la referencia cultural en-US, pero no en el Sami septentrional (Suecia) culture.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

Comentarios

El StringComparison enumeración se utiliza para especificar si una comparación de cadenas debe usar la referencia cultural actual o la referencia cultural invariable, una palabra o las reglas de ordenación ordinal y ser distingue mayúsculas de minúsculas o mayúsculas y 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

Cuando se llama a un método de comparación de cadenas como String.Compare, String.Equals, o String.IndexOf, siempre debe llamar a una sobrecarga que incluya un parámetro de tipo StringComparison para que pueda especificar el tipo de comparación que realiza el 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 obtener más información, consulte Procedimientos recomendados para el uso de cadenas.For more information, see Best Practices for Using Strings.

Una operación que utiliza reglas de ordenación de palabras realiza una comparación de la referencia cultural en la que algunos caracteres Unicode no alfanuméricos pueden tener asignados a ellos de pesos especiales.An operation that uses word sort rules performs a culture-sensitive comparison wherein certain nonalphanumeric Unicode characters might have special weights assigned to them. Mediante las reglas de ordenación de palabras y las convenciones de una referencia cultural concreta, el guión ("-") podría tener un peso muy pequeño asignado para que "coop" y "Co-op" aparecerían juntos en una lista ordenada.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 Xore que se ejecutan solo en sistemas Linux y macOS: El comportamiento de la intercalación para las referencias culturales de C y Posix siempre distingue mayúsculas de minúsculas porque estas referencias culturales no usan el orden esperado de la intercalación de 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. Se recomienda que utilice una referencia cultural que no sea de C o Posix para realizar operaciones de ordenación que tengan en cuenta la referencia cultural y no distingan mayúsculas y minúsculas.We recommend that you use a culture other than C or Posix for performing culture-sensitive, case-insensitive sorting operations.

Una operación que utiliza las reglas de ordenación ordinal realiza una comparación en función del valor numérico (punto de código Unicode) de cada Char en la cadena.An operation that uses ordinal sort rules performs a comparison based on the numeric value (Unicode code point) of each Char in the string. Una comparación ordinal es rápido pero cuenta la referencia cultural.An ordinal comparison is fast but culture-insensitive. Cuando usa las reglas de ordenación ordinal para ordenar las cadenas que comienzan con caracteres Unicode (U +), la cadena U + xxxx viene antes de la cadena U + aaaa si el valor de xxxx es numéricamente 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 obtener más información acerca de las comparaciones, vea el System.String clase comentarios.For more information about comparisons, see the System.String class remarks. Para obtener más información acerca de la referencia cultural, consulte el System.Globalization.CultureInfo clase comentarios.For more information about culture, see the System.Globalization.CultureInfo class remarks. Para obtener instrucciones sobre cuándo usar las reglas de comparación ordinal o la referencia cultural o las reglas de la referencia cultural invariable, vea prácticas recomendadas para el uso de cadenas.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 un conjunto de archivos de texto que contienen información sobre los pesos de caracteres utilizados en operaciones de ordenación y comparación para los sistemas operativos de Windows, consulte tablas ordenación 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 la tabla de peso para Linux y macOS, consulte el predeterminada la tabla de elementos de la intercalación de Unicode.For the sort weight table for Linux and macOS, see the Default Unicode Collation Element Table.

Se aplica a

Consulte también: