Question

edit: I based this question on a false assumption – that the generic type instance lookups I was doing would be the doinf same work as when done on generic types created at runtime. The ones in my harness are accessible to the compiler so it can compile them into address lookups. I’m still pretty interested in what .MakeGenericType does behind the scenes.

I’ve just done a quick comparison between getting a value from a IDictionary and getting a value from generic type with a static property.

Results for 100000000 lookups:

Dictionary: 14.5246952
Generic type: 00.2513280

What kind of magic is .NET using in the background to map to the instance of the Generic so quickly? I would have thought something similar to a hashtable would have to be used to lookup. Maybe it gets JITTED… I don’t know! Do you?

Here’s my test harness – I’m sure it’s full of mistakes so let me know what needs fixing!

void Main()
{
    var sw = new Stopwatch();
    var d = new Dictionary<Type, object>() 
    { 
     { typeof(string), new object() },
     { typeof(int), new object() } 

    };
    var stringType = typeof(string);
    var intType = typeof(int);
    sw.Start();
    for (var i = 0; i < 100000000; i++)
    {
        Debug.Assert(d[stringType] != d[intType]);
    }
    sw.Stop();
    sw.Elapsed.Dump();
    sw.Reset();

    Lookup<string>.o = new object();
    Lookup<int>.o = new object();
    sw.Start();
    for (var i = 0; i < 100000000; i++)
    {
        Debug.Assert(Lookup<string>.o != Lookup<int>.o);
    }
    sw.Stop();
    sw.Elapsed.Dump();
}

class Lookup<T>
{
    public static object o;
}

Answer 1

I think that mappings to your generics are made at compile time, whereas dictionary performs lookup in runtime.