IsGuid()

Habe da noch eine Alternative gefunden, diese verwendet aber das Guid-Object und kein Regex?

1 public static bool IsGuid(object guidValue)
2 {
3 if(guidValue.GetType() == typeof(Guid))
4 return true;
5
6 Guid guid;
7 try
8 {
9 guid = new Guid(guidValue.ToString());
10 return true;
11 }
12 catch
13 {
14 return false;
15 }
16 }

Das Ergebnis ist natürlich das Gleiche (wie immer, mehrere Wege nach Rom und so ...), aber ich würde mal spontan vermuten, dass diese Variante "teurer" im Sinne von aufwändiger ist, und damit etwas länger braucht. Kann mich aber auch täuschen.

Kann man jedenfalls beides verwenden :-)

Also habe das mal getestet:

Welcome to PerformaceTest:
Schleifengröße: 10000000
IsGUID(string)
Der erste Test dauerte: 94812,5 ms

IsGuid(object)
Der zweite Test dauerte: 24390,625 ms

Beim ersten Test lag die CPU bei mir bei ca. 60%
Beim zweiten bei ca. 50%

Also das es viermal schneller ist hätte ich spontan auch nicht gedacht! :)

Okay, überzeugt ;-) Trage es mal oben mit ein. Danke dir!

Also ich habs jetzt nochmal probiert, mit folgendem Testprogramm:

using System;
using System.Collections.Generic;
using System.Text;
using System.Text.RegularExpressions;

namespace SpeedTestIsGuid
{
class Program
{
static void Main(string[] args)
{

string validGuid = Guid.NewGuid().ToString();
string invalidGuid = "dkhsfdsklfbsdn";

Console.WriteLine("Gültige Guid: {0}", validGuid);
Console.WriteLine("Ungültige Guid: {0}", invalidGuid);

Console.WriteLine("Starte Test ...");

int start, falseCount, trueCount;

start = Environment.TickCount;
trueCount = falseCount = 0;

// Teste Variante 1
for (int i = 0; i
/// Variante 1
///
///
///
public static bool IsGUID(string strGUID)
{
try
{
Regex GUIDPattern = new Regex("[A-Z0-9]{8}-[A-Z0-9]{4}-[A-Z0-9]{4}-[A-Z0-9]{4}-[A-Z0-9]{12}");
return GUIDPattern.IsMatch(strGUID.ToUpper());
}
catch
{
return false;
}
}

///
/// Variante 2
///
///
///
public static bool IsGUIDTPerformance(string strGUID)
{
if(!string.IsNullOrEmpty(strGUID))
{
Regex GUIDPattern = new Regex("[A-Z0-9]{8}-[A-Z0-9]{4}-[A-Z0-9]{4}-[A-Z0-9]{4}-[A-Z0-9]{12}");
return GUIDPattern.IsMatch(strGUID.ToUpper());
}
return false;
}

///
/// Variante 3
///
///
///
public static bool IsGuid(object guidValue)
{
if (guidValue.GetType() == typeof(Guid))
return true;

Guid guid;

try {
guid = new Guid(guidValue.ToString());
return true;
}
catch
{
return false;
}
}

}
}

Ergebnis:

Die Guid-Variante ist um ein Vielfaches schneller.

Variante 1: 3797 Millisekunden bei 100.000 Durchläufen
Variante 2: 3797 Millisekunden bei 100.000 Durchläufen
Variante 3: 198671 Millisekunden bei 100.000 Durchläufen

Also das genaue Gegenteil!?

Also, was soll ich sagen, habe soeben mein Testprogramm von gestern noch mal laufen lassen und Du hast Recht:

Welcome to PerformaceTest
Anzahl Durchläufe: 100000
Der erste Test dauerte:2828,125 ms
RETURN für den 2. Test:
Der zweite Test dauerte:84468,75 ms

Unglaublich - Da hatte mein Rechner gestern wohl den "new Guid Tag"!!! - Am Test Code habe ich nämlich nichts verändert. Da staunt der Laie - der Fachmann macht jetzt Feierabend :)

hätte mich auch gewundert, dass eine RegEx langsam gewesen wäre, dann man sollte gerade in dieser Hinsicht tunlichst auf RefEx zurückgreifen, sind halt extrem mächtig...!