Como: Comparar strings (guia de programação translation from VPE for Csharp)

Ao comparar cadeias de caracteres, você é produzir um resultado que indica uma seqüência de caracteres é maior ou menor que o Outros ou que as duas seqüências de caracteres são iguais.As regras pela qual o resultado é determinado são diferentes dependendo se você está realizando comparação ordinal or comparação sensíveis à cultura.É importante usar o tipo correto de comparação para a tarefa específica.

Use comparações ordinais básicas quando você tem que comparar ou classificar os valores de duas seqüências de caracteres sem considerar a convenções lingüísticas.Uma comparação ordinal básica (Ordinal) diferenciam diferenciar maiúsculas de minúsculas, que significa que as duas seqüências de caracteres devem coincidir com o caractere para caractere: "e" não é igual a "E" ou "E".Uma variação usados com freqüência é OrdinalIgnoreCase, que fará a correspondência "e", "E" e "E". StringComparison.OrdinalIgnoreCase freqüentemente usado para comparar os nomes de arquivos, nomes de caminhos, caminhos de rede e qualquer Outros seqüência de caracteres cujo valor não alterar com base na localidade do computador do usuário.

Comparações sensíveis à cultura costumam ser usadas para comparar e classificar cadeias de caracteres que são inseridas pelos usuários finais, como os caracteres e convenções de classificação destas seqüências de caracteres podem variar dependendo do local do computador do usuário.Até mesmo seqüências que contêm caracteres idênticos podem classificar de maneira diferente dependendo da cultura do thread corrente.

Observação:

Ao comparar cadeias de caracteres, você deve usar os métodos que especificar explicitamente o tipo de comparação que você pretende executar.Isso torna seu código muito mais legível e fácil manutenção.Sempre que possível, usar as sobrecargas dos métodos da System.String e System.Array classes que têm um StringComparison parâmetro de enumeração, para que você pode especificar o tipo de comparação para executar. É melhor evitar o uso do == e != operadores ao comparar cadeias de caracteres. Além disso, evite usar o String.CompareTo métodos de instância porque nenhuma das sobrecargas leva uma StringComparison.

Exemplo

O exemplo a seguir mostra como comparar cadeias de caracteres cujos valores não serão alterada com base na localidade do computador do usuário corretamente.Além disso, ele demonstra também o string interning o recurso de translation from VPE for Csharp.Quando um programa declara duas ou mais variáveis de seqüência de caracteres idênticos, o compilador armazena tudo no mesmo local.Chamando o ReferenceEquals método, você pode ver que as duas seqüências de caracteres, na verdade, se referir ao mesmo objeto em memória. Use o String.Copy método para evitar interning, conforme mostrado no exemplo.

// Internal strings that will never be localized.
string root = @"C:\users";
string root2 = @"C:\Users";

// Use the overload of the Equals method that specifies a StringComparison.
// Ordinal is the fastest way to compare two strings.
bool result = root.Equals(root2, StringComparison.Ordinal);

Console.WriteLine("Ordinal comparison: {0} and {1} are {2}", root, root2,
                    result ? "equal." : "not equal.");

// To ignore case means "user" equals "User". This is the same as using
// String.ToUpperInvariant on each string and then performing an ordinal comparison.
result = root.Equals(root2, StringComparison.OrdinalIgnoreCase);
Console.WriteLine("Ordinal ignore case: {0} and {1} are {2}", root, root2,
                     result ? "equal." : "not equal.");

// A static method is also available.
bool areEqual = String.Equals(root, root2, StringComparison.Ordinal);


// String interning. Are these really two distinct objects?
string a = "The computer ate my source code.";
string b = "The computer ate my source code.";

// ReferenceEquals returns true if both objects
// point to the same location in memory.
if (String.ReferenceEquals(a, b))
    Console.WriteLine("a and b are interned.");
else
    Console.WriteLine("a and b are not interned.");

// Use String.Copy method to avoid interning.
string c = String.Copy(a);

if (String.ReferenceEquals(a, c))
    Console.WriteLine("a and c are interned.");
else
    Console.WriteLine("a and c are not interned.");

O exemplo a seguir mostra como comparar a forma preferida de seqüências de caracteres usando o System.String métodos que adotam uma StringComparison enumeração. Observe que o String.CompareTo métodos de instância não são usados aqui, porque nenhuma das sobrecargas leva uma StringComparison.

// "They dance in the street."
// Linguistically (in Windows), "ss" is equal to 
// the German essetz: 'ß' character in both en-US and de-DE cultures.
string first = "Sie tanzen in die Straße."; 
string second = "Sie tanzen in die Strasse.";

Console.WriteLine("First sentence is {0}", first);
Console.WriteLine("Second sentence is {0}", second);

// Store CultureInfo for the current culture. Note that the original culture
// can be set and retrieved on the current thread object.
System.Threading.Thread thread = System.Threading.Thread.CurrentThread;
System.Globalization.CultureInfo originalCulture = thread.CurrentCulture;

// Set the culture to en-US.
thread.CurrentCulture = new System.Globalization.CultureInfo("en-US");

// For culture-sensitive comparisons, use the String.Compare 
// overload that takes a StringComparison value.
int i = String.Compare(first, second, StringComparison.CurrentCulture);
Console.WriteLine("Comparing in {0} returns {1}.", originalCulture.Name, i);

// Change the current culture to Deutch-Deutchland.
thread.CurrentCulture = new System.Globalization.CultureInfo("de-DE");
i = String.Compare(first, second, StringComparison.CurrentCulture);
Console.WriteLine("Comparing in {0} returns {1}.", thread.CurrentCulture.Name, i);

// For culture-sensitive string equality, use either StringCompare as above
// or the String.Equals overload that takes a StringComparison value.
thread.CurrentCulture = originalCulture;
bool b = String.Equals(first, second, StringComparison.CurrentCulture);
Console.WriteLine("The two strings {0} equal.", b == true ? "are" : "are not");

/*
 * Output:
    First sentence is Sie tanzen in die Straße.
    Second sentence is Sie tanzen in die Strasse.
    Comparing in current culture returns 0.
    The two strings are equal.
 */

O exemplo a seguir mostra como classificar e pesquisar seqüências de caracteres em uma matriz de maneira sensíveis à cultura, usando o estáticoArray métodos que adotam uma System.StringComparer parâmetro.

class SortStringArrays
{
    static void Main()
    {

        string[] lines = new string[]
        {
            @"c:\public\textfile.txt",
            @"c:\public\textFile.TXT",
            @"c:\public\Text.txt",
            @"c:\public\testfile2.txt"
        };

        Console.WriteLine("Non-sorted order:");
        foreach (string s in lines)
        {
            Console.WriteLine("   {0}", s);
        }

        Console.WriteLine("\n\rSorted order:");

        // Specify Ordinal to demonstrate the different behavior.
        Array.Sort(lines, StringComparer.Ordinal);

        foreach (string s in lines)
        {
            Console.WriteLine("   {0}", s);
        }


        string searchString = @"c:\public\TEXTFILE.TXT";
        Console.WriteLine("Binary search for {0}", searchString);
        int result = Array.BinarySearch(lines, searchString, StringComparer.OrdinalIgnoreCase);
        ShowWhere<string>(lines, result);

        //Console.WriteLine("{0} {1}", result > 0 ? "Found" : "Did not find", searchString);

        // Keep the console window open in debug mode.
        System.Console.WriteLine("Press any key to exit.");
        System.Console.ReadKey();
    }

    // Displays where the string was found, or, if not found,
    // where it would have been located.
    private static void ShowWhere<T>(T[] array, int index)
    {
        if (index < 0)
        {
            // If the index is negative, it represents the bitwise
            // complement of the next larger element in the array.
            index = ~index;

            Console.Write("Not found. Sorts between: ");

            if (index == 0)
                Console.Write("beginning of array and ");
            else
                Console.Write("{0} and ", array[index - 1]);

            if (index == array.Length)
                Console.WriteLine("end of array.");
            else
                Console.WriteLine("{0}.", array[index]);
        }
        else
        {
            Console.WriteLine("Found at index {0}.", index);
        }
    }


}
/*
 * Output:
    Non-sorted order:
       c:\public\textfile.txt
       c:\public\textFile.TXT
       c:\public\Text.txt
       c:\public\testfile2.txt

    Sorted order:
       c:\public\Text.txt
       c:\public\testfile2.txt
       c:\public\textFile.TXT
       c:\public\textfile.txt
    Binary search for c:\public\TEXTFILE.TXT
    Found at index 2.
 */

Classes de coleção, sistema autônomo System.Collections.Hashtable, System.Collections.Generic.Dictionary<TKey, TValue>, e System.Collections.Generic.List<T> tem construtores que utilizam um System.StringComparer parâmetro quando o tipo de elementos ou chaves é string. Em geral, você deve usar esses construtores sempre que possível e especificar um dos Ordinal ou OrdinalIgnoreCase.

Consulte também

Conceitos

Comparando Seqüências de Caracteres

Referência

Sequências (guia de programação C#)

System.Globalization.CultureInfo

System.StringComparer

Outros recursos

Globalizando e Localizando Aplicativos