Question

There is a very easy trick which creates a dictionary-like structure where keys are types.
The structure acts like a Dictionary<Type, T?> where keys are Type objects and values are instances of the corresponding types.

This wonderful structure is as fast as just a variable or array since the “lookup” is only done once by the compiler/JITter and the proper value reference is compiled into your program.

    public static class MyDict<T> {
        public static T Value { get; set; }
    }

You can work with that structure like this:

MyDict<string>.Value = MyDict<int>.Value.ToString();

The problem is that this “dictionary” is global. The only way to create different dictionaries is to create different classes.

How can create a similar (fastest “lookup”, no boxing) non-static structure? (Without code generation.)

Simply said: I want to have multiple Dictionary<Type, object>-like objects without lookup costs, casting and boxing.

Answer 1

Ark-kun is using generics to essentially generate unique types at compile time. With a generic type, any static members are unique to that specific closed generic type. This way it’s processed as fast as a standard static member lookup.

The above usage is equivalent to something like this:

public static class MyDict_String 
{
    public static string Value { get; set; }
}

public static class MyDict_Int32
{
    public static int Value { get; set; }
}

MyDict_String.Value = MyDict_Int32.Value.ToString();

AFAIK, types are “static” (in that you can’t define more than one that way) so I don’t know of a way to cheat around this and maintain the same performance of a statically compiled member lookup.

Your best bet otherwise (I think) is to create a generic instance type that wraps its own dictionary that uses System.Type for its keys and System.Object for its values to which you have to perform boxing/casting when inserting/retrieving values.

EDIT: Here’s a simple implementation wrapping a dictionary:

public class MyTypedDict
{
    private Dictionary<Type, object> Values = new Dictionary<Type, object>();

    public T Get<T>()
    {
        object untypedValue;
        if (Values.TryGetValue(typeof(T), out untypedValue))
            return (T)untypedValue;
        return default(T);
    }

    public void Set<T>(T value)
    {
        Values[typeof(T)] = value;
    }
}

Thinking about it more, it might be possible to achieve a more property-like syntax using an ExpandoObject (http://msdn.microsoft.com/en-us/library/system.dynamic.expandoobject.aspx) through some tomfoolery, but I feel like this would be pretty abusive and I can only assume terribly prone to runtime errors. (plus it would afford you nothing at compile time)

EDITx2: If you really want to have different sets of values, you could nest it within another generic type:

public static class ValueSets<T>
{
    public static class MyDict<U>
    {
        public static U Value { get; set; }
    }
}

With usage like:

ValueSets<int>.MyDict<string>.Value = "Hello ";
ValueSets<bool>.MyDict<string>.Value = "World!";

string helloworld = ValueSets<int>.MyDict<string>.Value + ValueSets<bool>.MyDict<string>.Value;
Console.WriteLine(helloworld);//Hello World!

But then the initial type int and bool in this case become “magical” and without meaning, plus you would need to provide a unique type per distinct set of values you’d like to use. Plus you could not pass it around and modify as an instance variable, rather it’d be statically accessible (so long as you have access to use the type T). So perhaps you could declare minimally visible types that are named with meaning and use those:

internal class MyFirstWords {}
internal class MySecondWords {}

ValueSets<MyFirstWords>.MyDict<string>.Value = "Hello ";
ValueSets<MySecondWords>.MyDict<string>.Value = "World!";

string helloworld = ValueSets<MyFirstWords>.MyDict<string>.Value + ValueSets<MySecondWords>.MyDict<string>.Value;
Console.WriteLine(helloworld);//Hello World!

Regardless, I think this is quite wacky and I wouldn’t recommend it.