Comparar cadeias de caracteres em C#

Comparas as cadeias para responder a uma de duas perguntas: Estas duas cadeias são iguais? Ou em que ordem é que estas cadeias são ordenadas? C# permite-te controlar dois fatores independentes quando respondes a qualquer uma das perguntas:

• Distinção entre maiúsculas e minúsculas — se "Hello" e "hello" são tratados como iguais.
• Tipo de comparação — ordinal (compare o valor binário de cada carácter) ou consciente da cultura (aplicar as regras linguísticas de uma cultura).

A StringComparison enumeração combina estes fatores num único valor que passa aos métodos de comparação.

Comparar para verificar a igualdade

O método String.Equals e o operador == efetuam ambos, por predefinição, uma comparação ordinal sensível a maiúsculas e minúsculas. A comparação ordinal verifica o valor binário de cada carácter, por isso é rápido e dá o mesmo resultado em todas as máquinas. Pode tornar a sua intenção explícita chamando a sobrecarga que recebe um 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 ignorar o caso mantendo a semântica ordinal, passe 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

Compare por ordem de ordenação

Para determinar a ordem de ordenação em vez da igualdade, use String.Compare. Devolve um número negativo, zero ou positivo para indicar se a primeira cadeia está ordenada antes, na mesma posição ou depois da segunda:

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 com constantes com correspondência de padrões is ou switch

Quando o valor comparado é uma constante, pode usar o is operador com padrão constante como alternativa legível 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 uma cadeia com várias constantes, use uma switch expressão. Cada braço testa um padrão constante, e o padrão de descarte (_) trata de todos os valores que não correspondem. O exemplo seguinte mapeia uma palavra-chave de direção para uma instrução de viagem:

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.

Uma expressão switch que testa constantes de cadeias de caracteres realiza a mesma comparação ordinal sensível a maiúsculas e minúsculas que ==, pelo que "north" não corresponde ao ramo "North".

Escolha a comparação certa

Escolha o tipo de comparação com base nos dados, não por hábito:

• Para identificadores, caminhos de ficheiros, tokens de protocolo e outro texto definido por máquina, use Ordinal (ou OrdinalIgnoreCase para ignorar maiúsculas/minúsculas). A comparação de ordinais é rápida e consistente entre culturas.
• Para texto que os utilizadores leem e ordenam, como nomes ou títulos de produtos, use CurrentCulture para que a ordem corresponda às expectativas do utilizador.

A comparação consciente da cultura aplica regras linguísticas que variam consoante a cultura e podem produzir resultados surpreendentes. Por exemplo, algumas culturas tratam "ss" e "ß" como iguais, e a ordem das cordas pode mudar entre máquinas. Devido a essa variabilidade, reserve a comparação sensível à cultura para texto genuinamente em linguagem natural e use o mesmo tipo de comparação ao ordenar e pesquisar numa coleção.

Para um tratamento aprofundado da comparação sensível à cultura, incluindo considerações de globalização e diferenças de plataforma, consulte Melhores práticas para comparar cadeias em .NET.

Consulte também

• Melhores práticas para comparar cadeias em .NET
• Strings de pesquisa em C#
• StringComparison
• String.Compare