Início / coding / Perguntas / 78463995
Accepted
Theodor Zoulias
Asked: 2024-05-11 16:57:14 +0800 CST

Não há diferença entre CurrentCulture e CurrentCultureIgnoreCase, por quê?

  • 772

Estou tentando ordenar uma sequência de letras utilizando o Orderoperador LINQ e não estou obtendo o resultado esperado. Eu esperava que passar the StringComparer.CurrentCultureproduzisse uma ordem diferente da passagem the StringComparer.CurrentCultureIgnoreCase, mas ambos parecem ignorar o caso das minhas cartas:

string[] letters = ["y", "X", "Z"];
Console.WriteLine(String.Join(", ", letters.Order(StringComparer.CurrentCulture)));
Console.WriteLine(String.Join(", ", letters.Order(StringComparer.CurrentCultureIgnoreCase)));

Saída:

X, y, Z
X, y, Z

Demonstração on-line .

Eu esperava que CurrentCulturefosse sensível ao caso das letras e produzisse esta ordem: X, Z, y, porque as letras minúsculas em inglês estão mais distantes no gráfico ASCII do que as letras maiúsculas em inglês. O que não estou entendendo corretamente?

c#

2 respostas

  1. Best Answer

    A diferença entre StringComparer.CurrentCulturee StringComparer.CurrentCultureIgnoreCaseé relevante quando você tem dois valores que possuem a mesma string/texto, mas podem ter casos diferentes. No seu exemplo, ["y", "X", "Z"]as strings são todas "diferentes", pois "x" ainda vem antes de "y" e "y" ainda vem antes de "z". E isso não tem nada a ver com os casos dessas strings.

    Mas quando o algoritmo de ordenação vê uma lista como ["x", "X", "X", "x", "x", "X"]há uma diferença se os valores "x"e "X"devem ser iguais em relação à ordenação (então o Compare()método retorna 0) ou se devem ser diferentes (então o Compare()método retornará -1/ 1ou qualquer outro valor menor/maior zero ).

    Quando você usa o seguinte código:

    string[] letters = ["y", "X", "Z", "X", "x", "y", "Y", "z", "Z", "y", "Y", "z", "Z"];
Console.WriteLine(String.Join(", ", letters.Order(StringComparer.CurrentCulture)));
Console.WriteLine(String.Join(", ", letters.Order(StringComparer.CurrentCultureIgnoreCase)));

    você obterá o seguinte resultado :

    x, X, X, y, y, y, Y, Y, z, z, Z, Z, Z
X, X, x, y, y, Y, y, Y, Z, z, Z, z, Z

    Na segunda linha, todas as letras "iguais" são iguais entre si, o caso é literalmente ignorado conforme as instruções. E como o algoritmo de classificação é estável , a ordem relativa das "mesmas" letras ainda está na mesma ordem original (aqui na letra "y"):

    ["y", "X", "Z", "X", "x", "y", "Y", "z", "Z", "y", "Y", "z", "Z"]
  ^                        ^    ^              ^    ^
  1                        2    3              4    5

    X, X, x, y, y, Y, y, Y, Z, z, Z, z, Z
         ^  ^  ^  ^  ^
         1  2  3  4  5
    • 3

  2. Pelo que entendi, isso acontece porque esses comparadores realizam comparações linguísticas :

    Essa comparação linguística às vezes é chamada de "ordem de classificação de palavras".

    E você esperava o ordinal.

    Dos documentos :

    Você compara strings para responder a uma das duas perguntas: "Essas duas strings são iguais?" ou "Em que ordem essas strings devem ser colocadas ao classificá-las?"

    Essas duas questões são complicadas por fatores que afetam as comparações de strings:

    • Você pode escolher uma comparação ordinal ou linguística.
    • Você pode escolher se o caso é importante.
    • Você pode escolher comparações específicas da cultura.
    • As comparações linguísticas dependem da cultura e da plataforma.

    Os System.StringComparisoncampos de enumeração representam estas opções:

    • CurrentCulture: compare strings usando regras de classificação sensíveis à cultura e a cultura atual.
    • CurrentCultureIgnoreCase: compare strings usando regras de classificação sensíveis à cultura, a cultura atual e ignorando o caso das strings que estão sendo comparadas.
    • InvariantCulture: compare strings usando regras de classificação sensíveis à cultura e a cultura invariável.
    • InvariantCultureIgnoreCase: compare strings usando regras de classificação sensíveis à cultura, a cultura invariável e ignorando o caso das strings que estão sendo comparadas.
    • Ordinal: compare strings usando regras de classificação ordinal ( binária ).
    • OrdinalIgnoreCase: compare strings usando regras de classificação ordinal ( binária ) e ignorando o caso das strings que estão sendo comparadas.

    Daí a mudança para as contrapartes oridnais:

    Console.WriteLine(String.Join(", ", letters.Order(StringComparer.Ordinal)));
Console.WriteLine(String.Join(", ", letters.Order(StringComparer.OrdinalIgnoreCase)));

    Resultará na saída esperada:

    X, Z, y
X, y, Z

    Demonstração @sharplab.io

    • 1

relate perguntas