在C＃中打开Guid的最有效方法

Question

So in C# the switch statement only supports integral types (not Guids), so a simple O(1) comparison table doesn't look possible.

What is the most computationally efficient way to match on a Guid

At first I thought

if(gMyGuid == new Guid("VALUE"))
else if (gMyGuid == new Guid("VALUE2")
else if (gMyGuid == new Guid("VALUE3")
...
else if (gMyGuid == new Guid("VALUEn")

However by doing this I'm creating a new instance of the Guid each time for a comparison. I could convert the Guid to a string then compare on the string but the string comparison is a pretty long string for comparison.

Any advise is gratefully received.

Answer 1

You can create a System.Collections.Generic.Dictionary <Guid, ...> where ... is something useful to you.

Upon program startup, fill the dictionary with the guids and values that you need to recognize.

Then, use the TryGetValue method of the dictionary to retrieve a value by its guid.

I haven't stated anything literal for ... because I don't know what you want to do with the guids. Maybe you want to run some function, then a method pointer ( Func<T> or something like that) might be appropriate, or otherwise an interface type that provides the method you want to invoke. This depends on the context/purpose of that guid comparing code.

Answer 2

Maybe these links will answer your question...

How expensive is a GUID cast and comparison vs a string comparison

Performance - using Guid object or Guid string as Key

If nothing else it contains a starting point for a program that can do benchmarks tests of any approach you wish to try.

Answer 3

with c#7 you can now use switch with Pattern Matching for this purpose.

switch (gMyGuid )
{
    case var g when (g == new Guid("VALUE")):
        break;
    case var g when (g == new Guid("VALUE2")):
        break;
    case var g when (g == new Guid("VALUEN")):
        break;
    default:
        break;
}

This also works if you have defined static readonly new Guid"..") variables.

Answer 4

Create the compare values as static so you only created them once.

At the top of your class add:

private static Guid guidVal1 = new Guid("VALUE");

And then in your method:

if(gMyGuid == guidVal1)
else if .... 

Answer 5

If you're really concerned about performance, the constructors using numeric arguments are faster than the Guid(string) constructor. No strings involved and no need to parse anything.

This is the implementation of one of them:

public Guid(int a, short b, short c, byte d, byte e, byte f, byte g, byte h, byte i, byte j, byte k)
{
    this._a = a;
    this._b = b;
    this._c = c;
    this._d = d;
    this._e = e;
    this._f = f;
    this._g = g;
    this._h = h;
    this._i = i;
    this._j = j;
    this._k = k;
}

Sure, it's not as pretty to look at, but i think it's the fastest constructor possible. Also, you could of course store all your comparison Guids in a Dictionary and use the values in it to store a handler for each.

Answer 6

I don't know where your GUIDs are coming from, but you could consider refactoring the code into the strategy pattern to make it more maintainable as mentioned by a commenter.

This article is a good summary:

http://jeremyjarrell.org/archive/2007/10/28/64.aspx

Answer 7

I'd create a HashSet(T) of Guids, initialize it at startup.

Instead of the lengty 'if , if, if ' you get a

if (GuidHashSet.Contains(gMyGuid)) {}

and you could add new Guids to the HashSet if required. HashSet Contains() is an O(1) operation.

Make them all Guids (just once) as Guid == Guid uses the internal data of the Guid to compare them (equals is overloaded in Guid.cs). So comparing Guid == Guid is fastest. Which the HastSet will do.

Answer 8

The Guid equality operator (==) is overloaded so to compare just the values:

http://msdn.microsoft.com/en-us/library/system.guid.op_equality(v=VS.90).aspx

if(gMyGuid == myGuid)
...