Quando si eseguono confronti senza distinzione tra maiuscole e minuscole, è più efficiente convertire la stringa in maiuscolo o minuscolo? Ha importanza?

In questo post SO si suggerisce che C # sia più efficiente con ToUpper perché "Microsoft lo ha ottimizzato in questo modo". Ma ho anche letto questo argomento secondo cui la conversione di ToLower rispetto a ToUpper dipende da cosa contengono più stringhe e che in genere le stringhe contengono più caratteri minuscoli che rendono ToLower più efficiente.

In particolare, vorrei sapere:

• C'è un modo per ottimizzare ToUpper o ToLower in modo che uno sia più veloce dell'altro?
• È più veloce fare un confronto senza distinzione tra maiuscole e minuscole tra stringhe maiuscole o minuscole e perché?
• Esistono ambienti di programmazione (es. C, C #, Python, qualunque cosa) in cui un caso è chiaramente migliore dell'altro e perché?

La conversione in maiuscolo o minuscolo per fare confronti senza distinzione tra maiuscole e minuscole non è corretta a causa delle caratteristiche "interessanti" di alcune culture, in particolare la Turchia. Utilizzare invece un StringComparer con le opzioni appropriate.

MSDN ha alcune ottime linee guida sulla gestione delle stringhe. Potresti anche voler verificare che il tuo codice superi il test della Turchia .

EDIT: nota il commento di Neil sui confronti ordinali senza distinzione tra maiuscole e minuscole. L'intero regno è piuttosto oscuro :(

Da Microsoft su MSDN:

Best practice per l'utilizzo di stringhe in .NET Framework

Raccomandazioni per l'uso delle stringhe

• Utilizzare il metodo String.ToUpperInvariant invece del metodo String.ToLowerInvariant quando si normalizzano le stringhe per il confronto.

Perché? Da Microsoft :

Normalizza le stringhe in maiuscolo

C'è un piccolo gruppo di caratteri che una volta convertito in minuscolo non può fare un viaggio di andata e ritorno.

Qual è l'esempio di un personaggio del genere che non può fare un viaggio di andata e ritorno?

• Inizio : simbolo greco Rho (U + 03f1) ϱ
• Maiuscolo: Capitale greca Rho (U + 03a1) Ρ
• Minuscolo: piccolo greco Rho (U + 03c1) ρ

ϱ, Ρ , ρ

.NET Fiddle

Original: ϱ
ToUpper: Ρ
ToLower: ρ

Questo è il motivo per cui, se vuoi fare confronti senza distinzione tra maiuscole e minuscole, converti le stringhe in maiuscolo e non in minuscolo.

Quindi, se devi sceglierne uno, scegli Maiuscolo .

Secondo MSDN è più efficiente passare le stringhe e dire al confronto di ignorare il caso:

String.Compare (strA, strB, StringComparison.OrdinalIgnoreCase) è equivalente a ( ma più veloce ) chiamare

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

Questi confronti sono ancora molto rapidi.

Naturalmente, se stai confrontando una stringa più e più volte, questo potrebbe non essere valido.

Basato su stringhe che tendono ad avere più voci minuscole, ToLower dovrebbe teoricamente essere più veloce (molti confronti, ma pochi incarichi).

In C, o quando si utilizzano elementi accessibili individualmente di ogni stringa (come le stringhe C o il tipo di stringa STL in C ++), in realtà è un confronto di byte, quindi il confronto UPPERnon è diverso da lower.

Se fossi subdolo e invece caricassi le tue stringhe in longarray, otterresti un confronto molto veloce sull'intera stringa perché potrebbe confrontare 4 byte alla volta. Tuttavia, il tempo di caricamento potrebbe non renderlo utile.

Perché hai bisogno di sapere qual è il più veloce? A meno che tu non stia facendo un carico metrico di confronti, uno che esegue un paio di cicli più velocemente è irrilevante per la velocità di esecuzione complessiva e suona come un'ottimizzazione prematura :)

Microsoft ha ottimizzato ToUpperInvariant(), no ToUpper(). La differenza è che l'invariante è più adatto alla cultura. Se è necessario eseguire confronti senza distinzione tra maiuscole e minuscole su stringhe che possono variare in cultura, utilizzare Invariant, altrimenti le prestazioni della conversione invariante non dovrebbero avere importanza.

Non posso dire se ToUpper () o ToLower () sia più veloce però. Non l'ho mai provato da quando non ho mai avuto una situazione in cui le prestazioni fossero così importanti.

Se stai confrontando stringhe in C #, è molto più veloce usare .Equals () invece di convertire entrambe le stringhe in lettere maiuscole o minuscole. Un altro grande vantaggio per l'utilizzo di .Equals () è che non viene allocata più memoria per le 2 nuove stringhe maiuscole / minuscole.

Non dovrebbe mai importare. Con i caratteri ASCII, sicuramente non ha importanza: sono solo alcuni confronti e un po 'di capovolgimento per entrambe le direzioni. Unicode potrebbe essere un po 'più complicato, dal momento che ci sono alcuni caratteri che cambiano maiuscolo in modi strani, ma in realtà non dovrebbe esserci alcuna differenza a meno che il tuo testo non sia pieno di quei caratteri speciali.

Facendolo correttamente, dovrebbe esserci un piccolo, insignificante vantaggio di velocità se converti in minuscolo, ma questo, come molti hanno accennato, dipende dalla cultura e non è ereditato dalla funzione ma dalle stringhe che converti (molte lettere minuscole significa poche assegnazioni alla memoria) - la conversione in maiuscolo è più veloce se hai una stringa con molte lettere maiuscole.

Volevo alcuni dati reali su questo, quindi ho estratto l'elenco completo dei caratteri a due byte che falliscono con ToLowero ToUpper. Ho quindi eseguito questo test di seguito:

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);
   }
}

Risultato sotto. Nota ho anche provato con le Invariantversioni e il risultato è stato lo stesso. È interessante notare che una delle coppie fallisce con entrambi. Ma basato su questo ToUpper è l'opzione migliore .

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