¿Qué tan caro es un lanzamiento de GUID y la comparación frente a una comparación de cadena

Question

que sería más rápido?

bool same=(Guid)Identifier==id; 

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

Answer 1

He utilizado este código:

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

y consiguió este resultado para diferentes valores (mejor de los casos):

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! 

Y este resultado para el mismo valor (peor escenario)

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

A Guid Guid == utilizará un código como:

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

mientras que la comparación de cadenas en su ejemplo utilizará una comparación puntero inseguro.

Sin evaluación comparativa, sospecho que el Guid será más rápido, pero estamos hablando de marginal. Y realmente necesita elevar el número de comparaciones a los millones para que importe.

Ambas comparaciones saldrán temprano, es decir, de izquierda a derecha, por lo que también afectarán la velocidad. La comparación de cadenas tiene más comprobaciones antes de que ocurra la comparación y una llamada más al método también.

Answer 3

Una comparación de GUID es un memcmp de 16 bytes. No va a ser peor que una comparación de cadenas, pero si te preocupa tanto el rendimiento, no deberías usar código administrado.

Answer 4

En mis pruebas haciendo una comparación UUID-UUID recta VS comparación de String-String, la comparación de UUID toma aproximadamente 1/4 del tiempo como la comparación de Cadena.

Sin embargo, la conversión de String-> UUID es costosa. Mucho más caro que la conversión de UUID-> String. Ambos son más caros que cualquiera de los métodos de comparación.

Entonces: Si tiene dos UUID, compare los UUID directamente. Si tienes dos cadenas, compara las cadenas directamente. Si tiene un String y un UUID, convierta el UUID en un String y compare los Strings.

Answer 5

.NET Guid es una estructura de 16 bytes que cuando se representa como una cadena se formateará en este patrón "xxxxxxxx-xxxx- xxxx-xxxx-xxxxxxxxxxxx "que tiene unos 32 caracteres.

Representado como un GUID tomaría 16 bytes y representado como una cadena que tomaría 32 * 2 = 64 bytes.

Entonces GUID.Equals() debería funcionar mejor.

También GUID.Equals (GUID) funcionaría mejor que guid1 == guid2 porque no hay boxeo involucrado en el primero.