Wie teuer ist ein GUID-Cast und Vergleich gegen einen String-Vergleich

Question

was wäre schneller?

bool same=(Guid)Identifier==id; 

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

Answer 1

ich diesen Code verwendet:

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

Und bekam dieses Ergebnis für verschiedene Werte (bestes Szenario):

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! 

Und dieses Ergebnis für denselben Wert (schlimmeres Szenario)

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 Code wie verwenden:

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

während die Zeichenfolge in Ihrem Beispiel vergleichen, werden einen unsicheren Zeiger Vergleich verwenden.

Ohne Benchmarking, ich vermute, die Guid wird schneller sein, aber wir reden marginal. Und Sie müssen wirklich die Anzahl der Vergleiche zu den Multi-Millionen, um es wichtig zu machen.

Beide Vergleiche werden früh ausbrechen, also von links nach rechts, so dass auch die Geschwindigkeit beeinflusst wird. Der Zeichenfolgenvergleich enthält mehr Prüfungen, bevor der Vergleich stattfindet, und einen weiteren Methodenaufruf.

Answer 3

Ein GUID-Vergleich ist ein Memcmp von 16 Bytes. Es ist nicht schlimmer als ein String-Vergleich, aber wenn Sie Wert auf Leistung legen, sollten Sie keinen verwalteten Code verwenden.

Answer 4

In meiner Prüfung, die einen direkten UUID-UUID-Vergleich VS String-String-Vergleich durchführt, dauert der UUID-Vergleich etwa 1/4 der Zeit als der String-Vergleich.

Allerdings ist das Gießen von String-> UUID teuer. Viel teurer als die UUID-> String-Konvertierung. Beide sind teurer als die beiden Vergleichsmethoden.

So: Wenn Sie zwei UUIDs haben, vergleichen Sie die UUIDs direkt. Wenn Sie zwei Strings haben, vergleichen Sie die Strings direkt. Wenn Sie eine Zeichenfolge und eine UUID haben, konvertieren Sie die UUID in einen String und vergleichen Sie die Strings.

Answer 5

.NET Guid ist eine 16-Byte-Struktur, die, wenn sie als String dargestellt wird, in diesem Muster formatiert wird "xxxxxxxx-xxxx- xxxx-xxxx-xxxxxxxxxxxx "was ungefähr 32 Zeichen ist.

So dargestellt als eine GUID würde es 16 Bytes und als eine Zeichenfolge dargestellt würde es 32 * 2 = 64 Bytes dauern würde.

Also GUID.Equals() sollte besser funktionieren.

Auch GUID.Equals (GUID) würde besser funktionieren als guid1 == guid2, weil es keinen Boxing in ersterem gibt.