StringComparison Enum

Definition

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
public enum StringComparison
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public enum StringComparison
type StringComparison = 
Public Enum StringComparison
Inheritance
StringComparison
Attributes

Fields

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 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 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 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 4

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

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.

Examples

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

Remarks

La enumeración StringComparison se utiliza para especificar si una comparación de cadenas debe usar la referencia cultural actual o la referencia cultural de todos los idiomas, las reglas de ordenación de palabras o ordinales, y distingue entre mayúsculas y minúsculas o no.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.

Important

Cuando se llama a un método de comparación de cadenas como String.Compare, String.Equalso String.IndexOf, siempre se 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 usa reglas de ordenación de palabras realiza una comparación dependiente de la referencia cultural en la que algunos caracteres Unicode no alfanuméricos pueden tener asignados 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. Con las reglas de ordenación de palabras y las convenciones de una referencia cultural concreta, el guion ("-") podría tener asignado un peso muy pequeño para que "Coop" y "Co-op" aparezcan uno junto a otro 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.

Note

.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 usa reglas de ordenación ordinal realiza una comparación basada en el valor numérico (punto de código Unicode) de cada Char de 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ápida pero no tiene en cuenta la referencia cultural.An ordinal comparison is fast but culture-insensitive. Cuando se usan reglas de ordenación ordinal para ordenar cadenas que comienzan por caracteres Unicode (U +), la cadena U + xxxx viene antes de la cadena U + YYYY si el valor de XXXX es numéricamente inferior a 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 sobre las comparaciones, vea los comentarios de la clase System.String.For more information about comparisons, see the System.String class remarks. Para obtener más información acerca de la referencia cultural, consulte la sección Comentarios de la clase System.Globalization.CultureInfo.For more information about culture, see the System.Globalization.CultureInfo class remarks. Para obtener instrucciones sobre Cuándo usar las reglas de comparación ordinales o dependientes de la referencia cultural o las reglas de la referencia cultural de todos los idiomas, 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 obtener un conjunto de archivos de texto que contienen información sobre los pesos de caracteres utilizados en las operaciones de ordenación y comparación de los sistemas operativos Windows, vea ordenar tablas de pesos.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 obtener la tabla de peso de ordenación de Linux y macOS, consulte la tabla de elementos de intercalación Unicode predeterminada.For the sort weight table for Linux and macOS, see the Default Unicode Collation Element Table.

Applies to

See also