Quanto è costoso un cast GUID e confronto rispetto a un confronto di stringhe

Question

quale sarebbe più veloce?

bool same=(Guid)Identifier==id; 

bool same=String.Equals(string1,string2, StringComparison.OrdinalIgnoreCase); 

Answer 1

Ho usato questo codice:

object victim = Guid.Empty; 
Guid target = Guid.NewGuid(); 

Stopwatch sw = new Stopwatch(); 
sw.Start(); 
for (int i = 0; i < 10000000; i++){ 
    bool equal = ((Guid) victim) == target; 
} 
Console.WriteLine("Direct cast : {0}", sw.Elapsed); 

sw.Reset(); sw.Start(); 
for (int i = 0; i < 10000000; i++) 
{ 
    bool equal = Guid.Equals(victim, target); 
} 
Console.WriteLine("Guid.Equals : {0}", sw.Elapsed); 

sw.Reset(); sw.Start(); 
string a = victim.ToString(); // as suggested by Mikael 
string b = target.ToString(); 
for (int i = 0; i < 10000000; i++) 
{ 
    bool equal = String.Equals(a, b, StringComparison.OrdinalIgnoreCase); 
} 
Console.WriteLine("String.Equals : {0}", sw.Elapsed); 

Console.ReadLine(); 

e ottenuto questo risultato per diversi valori (scenario migliore):

object victim = Guid.Empty; 
Guid target = Guid.NewGuid(); 
// Direct cast : 00:00:00.1164198 
// Guid.Equals : 00:00:02.1268147 
// String.Equals : 00:00:00.4129527 // oh my! 

E questo risultato per lo stesso valore (scenario peggiore)

object victim = Guid.Empty; 
Guid target = Guid.Empty; 
// Direct cast : 00:00:00.2793173 
// Guid.Equals : 00:00:03.5625948 
// String.Equals : 00:00:01.7564302 

Answer 2

Un Guid Guid == utilizzerà il codice come:

public bool Equals(Guid g) 
{ 
if (g._a != this._a) 
{ 
    return false; 
} 
if (g._b != this._b) 
{ 
    return false; 
} 

mentre la stringa di confrontare nel tuo esempio utilizzerà un confronto puntatore non sicuro.

Senza il benchmark, sospetto che il Guid sarà più veloce, ma stiamo parlando di marginale. E hai davvero bisogno di aumentare il numero di confronti con i milioni di dollari per farli avere importanza.

Entrambi i confronti scoppiano in anticipo, ovvero da sinistra a destra, in modo da influire anche sulla velocità. Il confronto delle stringhe ha più controlli prima che avvenga il confronto e un'altra chiamata al metodo.

Answer 3

Un confronto GUID è un memcmp di 16 byte. Non sarà necessariamente peggio di un confronto tra stringhe, ma se ti preoccupi delle prestazioni tanto non dovresti usare il codice gestito.

Answer 4

Nel mio test eseguendo un confronto UUID-UUID diretto confronto VS String-String, il confronto UUID richiede circa 1/4 del tempo come confronto di String.

Tuttavia, il casting di String-> UUID è costoso. Molto più costoso della conversione UUID-> String. Entrambi sono più costosi di entrambi i metodi di confronto.

Quindi: Se due UUID confrontano direttamente gli UUID. Se hai due stringhe, confronta le stringhe direttamente. Se si dispone di una stringa e un UUID, convertire l'UUID in una stringa e confrontare le stringhe.

Answer 5

.NET Guid è una struttura a 16 byte che, quando rappresentata come una stringa, verrà formattata in questo modello "xxxxxxxx-xxxx- xxxx-xxxx-xxxxxxxxxxxx "che è di circa 32 caratteri.

Così rappresentato come un GUID ci vorrebbe 16 byte e rappresentato come una stringa ci vorrebbe 32 * 2 = 64 byte.

Quindi GUID.Equals() dovrebbe funzionare meglio.

Anche GUID.Equals (GUID) funzionerebbe meglio di guid1 == guid2 perché non ci sono boxe coinvolti nel primo.