Comparación de cadenas en C#

Las cadenas se comparan para responder a una de estas dos preguntas: ¿son iguales estas dos cadenas? o ¿En qué orden ordenan estas cadenas? C# le permite controlar dos factores independientes al responder a cualquiera de las preguntas:

• Distinción entre mayúsculas y minúsculas — si "Hello" y "hello" se consideran iguales.
• Tipo de comparación — ordinal (compara el valor binario de cada carácter) o dependiente de la configuración regional (aplica las reglas lingüísticas de una configuración regional).

La StringComparison enumeración combina estos factores en un único valor que se pasa a los métodos de comparación.

Comparar para ver si son iguales

El String.Equals método y el == operador realizan una comparación ordinal con distinción entre mayúsculas y minúsculas de forma predeterminada. La comparación ordinal comprueba el valor binario de cada carácter, por lo que es rápido y proporciona el mismo resultado en cada máquina. Puede hacer explícita la intención llamando a la sobrecarga que acepta un valor StringComparison:

string root = @"C:\users";
string root2 = @"C:\Users";

// Equals and == both perform a case-sensitive, ordinal comparison.
Console.WriteLine(root.Equals(root2));
// => False
Console.WriteLine(root == root2);
// => False

// Pass a StringComparison value to state the intent explicitly.
Console.WriteLine(root.Equals(root2, StringComparison.Ordinal));
// => False

Para no distinguir entre mayúsculas y minúsculas manteniendo la semántica ordinal, pase StringComparison.OrdinalIgnoreCase:

string root = @"C:\users";
string root2 = @"C:\Users";

// OrdinalIgnoreCase compares the binary values but ignores case.
bool equalIgnoringCase = string.Equals(root, root2, StringComparison.OrdinalIgnoreCase);
Console.WriteLine(equalIgnoringCase);
// => True

Comparar para ordenar

Para determinar el orden de clasificación en lugar de la igualdad, use String.Compare. Devuelve un número negativo, cero o un número positivo para indicar si la primera cadena se ordena antes, en la misma posición que o después del segundo:

string first = "Avocado";
string second = "Banana";

// Compare returns a negative number, zero, or a positive number
// to indicate sort order. Specify the comparison type explicitly.
int order = string.Compare(first, second, StringComparison.Ordinal);
Console.WriteLine(order < 0
    ? $"'{first}' sorts before '{second}'."
    : $"'{first}' sorts at or after '{second}'.");
// => 'Avocado' sorts before 'Banana'.

Comparar con constantes mediante coincidencia de patrones is o switch

Cuando el valor que compara es una constante, puede usar el is operador con un patrón constante como alternativa legible a ==:

string status = "Ready";

// When the right operand is a constant, the is operator and a
// constant pattern read as an alternative to ==.
if (status is "Ready")
{
    Console.WriteLine("The system is ready.");
}
// => The system is ready.

Para comparar una cadena con varias constantes, use una switch expresión . Cada brazo prueba un patrón constante y el patrón de descarte (_) controla todos los valores que no coinciden. El siguiente ejemplo asigna una palabra clave de dirección a una instrucción de desplazamiento:

foreach (string heading in new[] { "North", "South", "East", "West", "NE" })
{
    // A switch expression matches each constant pattern in turn and
    // returns the first match. The discard (_) handles every other value.
    string instruction = heading switch
    {
        "North" => "Travel due North for 10 km.",
        "South" => "Travel due South for 10 km.",
        "East" => "Travel due East for 10 km.",
        "West" => "Travel due West for 10 km.",
        _ => $"Unknown heading: {heading}.",
    };
    Console.WriteLine(instruction);
}
// => Travel due North for 10 km.
// => Travel due South for 10 km.
// => Travel due East for 10 km.
// => Travel due West for 10 km.
// => Unknown heading: NE.

Una expresión switch que comprueba constantes de cadena realiza la misma comparación ordinal con distinción entre mayúsculas y minúsculas que ==, por lo que "north" no coincide con la rama "North".

Elección de la comparación correcta

Elija el tipo de comparación en función de los datos, no por costumbre:

• Para identificadores, rutas de archivo, tokens de protocolo y otros textos definidos por la máquina, use Ordinal (o OrdinalIgnoreCase para no distinguir entre mayúsculas y minúsculas). La comparación ordinal es rápida y coherente entre referencias culturales.
• Para el texto que los usuarios leen y ordenan, como nombres o títulos de producto, use CurrentCulture para que el pedido coincida con las expectativas del usuario.

La comparación según la referencia cultural aplica reglas lingüísticas que varían según la cultura y pueden producir resultados sorprendentes. Por ejemplo, algunas configuraciones regionales consideran "ss" y "ß" como iguales, y el orden de las cadenas puede cambiar de un equipo a otro. Debido a esa variabilidad, reserve la comparación dependiente de la referencia cultural para texto auténtico en lenguaje natural, y use el mismo tipo de comparación siempre que ordene una colección y realice búsquedas en ella.

Para obtener un tratamiento detallado de la comparación cultural, incluidas las consideraciones de globalización y las diferencias de plataforma, consulte Procedimientos recomendados para comparar cadenas en .NET.

Consulte también

• Procedimientos recomendados para comparar cadenas en .NET
• Buscar cadenas en C#
• StringComparison
• String.Compare