Ao fazer comparações que não diferenciam maiúsculas de minúsculas, é mais eficiente converter a string em maiúsculas ou minúsculas? Isso importa mesmo?

É sugerido neste post do SO que o C # é mais eficiente com o ToUpper porque "a Microsoft o otimizou dessa maneira." Mas eu também li este argumento de que a conversão de ToLower vs. ToUpper depende do que suas strings contêm mais, e que normalmente as strings contêm mais caracteres minúsculos, o que torna ToLower mais eficiente.

Em particular, gostaria de saber:

• Existe uma maneira de otimizar ToUpper ou ToLower de forma que um seja mais rápido que o outro?
• É mais rápido fazer uma comparação sem distinção entre maiúsculas e minúsculas e por quê?
• Existe algum ambiente de programação (por exemplo, C, C #, Python, qualquer que seja) onde um caso é claramente melhor do que o outro e por quê?

Converter para maiúsculas ou minúsculas para fazer comparações que não diferenciam maiúsculas de minúsculas é incorreto devido a características "interessantes" de algumas culturas, particularmente a Turquia. Em vez disso, use um StringComparer com as opções apropriadas.

O MSDN tem algumas ótimas diretrizes sobre o manuseio de strings. Você também pode querer verificar se seu código passa no teste de Turquia .

EDIT: Observe o comentário de Neil sobre comparações ordinais que não diferenciam maiúsculas de minúsculas. Todo este reino é bastante obscuro :(

Da Microsoft no MSDN:

Práticas recomendadas para usar strings no .NET Framework

Recomendações para uso de string

• Use o método String.ToUpperInvariant em vez do método String.ToLowerInvariant ao normalizar strings para comparação.

Por quê? Da Microsoft :

Normalizar strings para maiúsculas

Há um pequeno grupo de caracteres que, quando convertidos para letras minúsculas, não podem fazer um percurso completo.

Qual é o exemplo de um personagem que não pode fazer uma viagem de ida e volta?

• Início : símbolo grego Rho (U + 03f1) ϱ
• Maiúsculas: Rho grego maiúsculo (U + 03a1) Ρ
• Minúsculas: Rho grego pequeno (U + 03c1) ρ

ϱ, Ρ , ρ

.NET Fiddle

Original: ϱ
ToUpper: Ρ
ToLower: ρ

É por isso que, se você quiser fazer comparações sem distinção entre maiúsculas e minúsculas, converta as strings em maiúsculas, e não em minúsculas.

Portanto, se você tiver que escolher um, escolha Maiúsculas .

De acordo com o MSDN , é mais eficiente passar as strings e dizer à comparação para ignorar maiúsculas e minúsculas:

String.Compare (strA, strB, StringComparison.OrdinalIgnoreCase) é equivalente a ( mas mais rápido que ) chamar

String.Compare (ToUpperInvariant (strA), ToUpperInvariant (strB), StringComparison.Ordinal).

Essas comparações ainda são muito rápidas.

Claro, se você estiver comparando uma corda repetidamente, isso pode não funcionar.

Com base em strings que tendem a ter mais entradas em minúsculas, ToLower deveria teoricamente ser mais rápido (muitas comparações, mas poucas atribuições).

Em C, ou ao usar elementos acessíveis individualmente de cada string (como strings C ou o tipo de string STL em C ++), é na verdade uma comparação de bytes - então comparar UPPERnão é diferente de lower.

Se você fosse sorrateiro e carregasse suas strings em longarrays, obteria uma comparação muito rápida de toda a string porque ela poderia comparar 4 bytes por vez. No entanto, o tempo de carregamento pode fazer com que não valha a pena.

Por que você precisa saber o que é mais rápido? A menos que você esteja fazendo um monte de comparações métricas, uma execução alguns ciclos mais rápido é irrelevante para a velocidade de execução geral e soa como otimização prematura :)

A Microsoft otimizou ToUpperInvariant(), não ToUpper(). A diferença é que invariante é mais amigável à cultura. Se você precisar fazer comparações que não diferenciam maiúsculas de minúsculas em strings que podem variar na cultura, use Invariante, caso contrário, o desempenho da conversão invariável não deve importar.

Não posso dizer se ToUpper () ou ToLower () é mais rápido. Nunca tentei, pois nunca tive uma situação em que o desempenho importasse tanto.

Se você estiver fazendo comparação de strings em C #, é significativamente mais rápido usar .Equals () em vez de converter ambas as strings em maiúsculas ou minúsculas. Outra grande vantagem para usar .Equals () é que mais memória não é alocada para as 2 novas strings maiúsculas / minúsculas.

Realmente não deveria importar. Com caracteres ASCII, definitivamente não importa - são apenas algumas comparações e um pouco de mudança para qualquer direção. Unicode pode ser um pouco mais complicado, já que existem alguns caracteres que mudam de caixa de maneira estranha, mas realmente não deve haver nenhuma diferença a menos que seu texto esteja cheio desses caracteres especiais.

Fazendo isso da maneira certa, deve haver uma pequena e insignificante vantagem de velocidade se você converter para minúsculas, mas isso é, como muitos sugeriram, dependente da cultura e não é herdado na função, mas nas strings que você converte (muitas letras minúsculas significa poucas atribuições na memória) - converter para maiúsculas é mais rápido se você tiver uma string com muitas letras maiúsculas.

Eu queria alguns dados reais sobre isso, então puxei a lista completa de dois caracteres de byte que falham com ToLowerou ToUpper. Em seguida, executei este teste abaixo:

using System;

class Program {
   static void Main() {
      char[][] pairs = {
new[]{'\u00E5','\u212B'},new[]{'\u00C5','\u212B'},new[]{'\u0399','\u1FBE'},
new[]{'\u03B9','\u1FBE'},new[]{'\u03B2','\u03D0'},new[]{'\u03B5','\u03F5'},
new[]{'\u03B8','\u03D1'},new[]{'\u03B8','\u03F4'},new[]{'\u03D1','\u03F4'},
new[]{'\u03B9','\u1FBE'},new[]{'\u0345','\u03B9'},new[]{'\u0345','\u1FBE'},
new[]{'\u03BA','\u03F0'},new[]{'\u00B5','\u03BC'},new[]{'\u03C0','\u03D6'},
new[]{'\u03C1','\u03F1'},new[]{'\u03C2','\u03C3'},new[]{'\u03C6','\u03D5'},
new[]{'\u03C9','\u2126'},new[]{'\u0392','\u03D0'},new[]{'\u0395','\u03F5'},
new[]{'\u03D1','\u03F4'},new[]{'\u0398','\u03D1'},new[]{'\u0398','\u03F4'},
new[]{'\u0345','\u1FBE'},new[]{'\u0345','\u0399'},new[]{'\u0399','\u1FBE'},
new[]{'\u039A','\u03F0'},new[]{'\u00B5','\u039C'},new[]{'\u03A0','\u03D6'},
new[]{'\u03A1','\u03F1'},new[]{'\u03A3','\u03C2'},new[]{'\u03A6','\u03D5'},
new[]{'\u03A9','\u2126'},new[]{'\u0398','\u03F4'},new[]{'\u03B8','\u03F4'},
new[]{'\u03B8','\u03D1'},new[]{'\u0398','\u03D1'},new[]{'\u0432','\u1C80'},
new[]{'\u0434','\u1C81'},new[]{'\u043E','\u1C82'},new[]{'\u0441','\u1C83'},
new[]{'\u0442','\u1C84'},new[]{'\u0442','\u1C85'},new[]{'\u1C84','\u1C85'},
new[]{'\u044A','\u1C86'},new[]{'\u0412','\u1C80'},new[]{'\u0414','\u1C81'},
new[]{'\u041E','\u1C82'},new[]{'\u0421','\u1C83'},new[]{'\u1C84','\u1C85'},
new[]{'\u0422','\u1C84'},new[]{'\u0422','\u1C85'},new[]{'\u042A','\u1C86'},
new[]{'\u0463','\u1C87'},new[]{'\u0462','\u1C87'}
      };
      int upper = 0, lower = 0;
      foreach (char[] pair in pairs) {
         Console.Write(
            "U+{0:X4} U+{1:X4} pass: ",
            Convert.ToInt32(pair[0]),
            Convert.ToInt32(pair[1])
         );
         if (Char.ToUpper(pair[0]) == Char.ToUpper(pair[1])) {
            Console.Write("ToUpper ");
            upper++;
         } else {
            Console.Write("        ");
         }
         if (Char.ToLower(pair[0]) == Char.ToLower(pair[1])) {
            Console.Write("ToLower");
            lower++;
         }
         Console.WriteLine();
      }
      Console.WriteLine("upper pass: {0}, lower pass: {1}", upper, lower);
   }
}

Resultado abaixo. Observe que também testei com as Invariantversões e o resultado foi exatamente o mesmo. Curiosamente, um dos pares falha com ambos. Mas com base nisso, ToUpper é a melhor opção .

U+00E5 U+212B pass:         ToLower
U+00C5 U+212B pass:         ToLower
U+0399 U+1FBE pass: ToUpper
U+03B9 U+1FBE pass: ToUpper
U+03B2 U+03D0 pass: ToUpper
U+03B5 U+03F5 pass: ToUpper
U+03B8 U+03D1 pass: ToUpper
U+03B8 U+03F4 pass:         ToLower
U+03D1 U+03F4 pass:
U+03B9 U+1FBE pass: ToUpper
U+0345 U+03B9 pass: ToUpper
U+0345 U+1FBE pass: ToUpper
U+03BA U+03F0 pass: ToUpper
U+00B5 U+03BC pass: ToUpper
U+03C0 U+03D6 pass: ToUpper
U+03C1 U+03F1 pass: ToUpper
U+03C2 U+03C3 pass: ToUpper
U+03C6 U+03D5 pass: ToUpper
U+03C9 U+2126 pass:         ToLower
U+0392 U+03D0 pass: ToUpper
U+0395 U+03F5 pass: ToUpper
U+03D1 U+03F4 pass:
U+0398 U+03D1 pass: ToUpper
U+0398 U+03F4 pass:         ToLower
U+0345 U+1FBE pass: ToUpper
U+0345 U+0399 pass: ToUpper
U+0399 U+1FBE pass: ToUpper
U+039A U+03F0 pass: ToUpper
U+00B5 U+039C pass: ToUpper
U+03A0 U+03D6 pass: ToUpper
U+03A1 U+03F1 pass: ToUpper
U+03A3 U+03C2 pass: ToUpper
U+03A6 U+03D5 pass: ToUpper
U+03A9 U+2126 pass:         ToLower
U+0398 U+03F4 pass:         ToLower
U+03B8 U+03F4 pass:         ToLower
U+03B8 U+03D1 pass: ToUpper
U+0398 U+03D1 pass: ToUpper
U+0432 U+1C80 pass: ToUpper
U+0434 U+1C81 pass: ToUpper
U+043E U+1C82 pass: ToUpper
U+0441 U+1C83 pass: ToUpper
U+0442 U+1C84 pass: ToUpper
U+0442 U+1C85 pass: ToUpper
U+1C84 U+1C85 pass: ToUpper
U+044A U+1C86 pass: ToUpper
U+0412 U+1C80 pass: ToUpper
U+0414 U+1C81 pass: ToUpper
U+041E U+1C82 pass: ToUpper
U+0421 U+1C83 pass: ToUpper
U+1C84 U+1C85 pass: ToUpper
U+0422 U+1C84 pass: ToUpper
U+0422 U+1C85 pass: ToUpper
U+042A U+1C86 pass: ToUpper
U+0463 U+1C87 pass: ToUpper
U+0462 U+1C87 pass: ToUpper
upper pass: 46, lower pass: 8