Can I Create a Dictionary of Generic Types?

Question

I\'d like to create a Dictionary object, with string Keys, holding values which are of a generic type. I imagine that it would look something like this:

Dict         


        

Answer 1

I prefer this way of putting generic types into a collection:

interface IList
{
  void Add (object item);
}

class MyList<T> : List<T>, IList
{
  public void Add (object item)
  {
    base.Add ((T) item); // could put a type check here
  }
}

class Program
{
  static void Main (string [] args)
  {
    SortedDictionary<int, IList>
      dict = new SortedDictionary<int, IList> ();

    dict [0] = new MyList<int> ();
    dict [1] = new MyList<float> ();

    dict [0].Add (42);
    dict [1].Add ("Hello"); // Fails! Type cast exception.
  }
}

But you do lose the type checks at compile time.

Answer 2

One of the way is to create a Dictionary value with type "object" like:

Dictionary<string, object> d = new Dictionary<string, object>();

So, here object datatype is used as a generic datatype, you can put anything in this as a value.

Answer 3

I didn't find what I was looking for here but after reading I think it might be what is being asked for so an attempt to answer.

The problem is that when you use Dictionary it is a closed constructed type and all elements must be of the TValue type. I see this question in a number of places without a good answer.

Fact is that I want indexing but each element to have a different type and based on the value of TKey we already know the type. Not trying to get around the boxing but trying to simply get more elegant access something like DataSetExtensions Field. And don't want to use dynamic because the types are known and it is just not wanted.

A solution can be to create a non generic type that does not expose T at the class level and therefore cause the TValue part of the dictionary to be closed constructed. Then sprinkle in a fluent method to help initialization.

public class GenericObject
{
    private object value;

    public T GetValue<T>()
    {
        return (T)value;
    }

    public void SetValue<T>(T value)
    {
        this.value = value;
    }

    public GenericObject WithValue<T>(T value)
    {
        this.value = value;
        return this;
    }
}

class Program
{
    static void Main(string[] args)
    {
        Dictionary<string, GenericObject> dict = new Dictionary<string, GenericObject>();

        dict["mystring"] = new GenericObject().WithValue<string>("Hello World");
        dict["myint"] = new GenericObject().WithValue<int>(1);

        int i = dict["myint"].GetValue<int>();
        string s = dict["mystring"].GetValue<string>();
    }
}

Answer 4

I came to a type safe implementation using ConditionalWeakTable.

public class FieldByType
{
    static class Storage<T>
        where T : class
    {
        static readonly ConditionalWeakTable<FieldByType, T> table = new ConditionalWeakTable<FieldByType, T>();

        public static T GetValue(FieldByType fieldByType)
        {
            table.TryGetValue(fieldByType, out var result);
            return result;
        }

        public static void SetValue(FieldByType fieldByType, T value)
        {
            table.Remove(fieldByType);
            table.Add(fieldByType, value);
        }
    }

    public T GetValue<T>()
        where T : class
    {
        return Storage<T>.GetValue(this);
    }

    public void SetValue<T>(T value)
        where T : class
    {
        Storage<T>.SetValue(this, value);
    }
}

It can be used like this:

/// <summary>
/// This class can be used when cloning multiple related objects to store cloned/original object relationship.
/// </summary>
public class CloningContext
{
    readonly FieldByType dictionaries = new FieldByType();

    public void RegisterClone<T>(T original, T clone)
    {
        var dictionary = dictionaries.GetValue<Dictionary<T, T>>();
        if (dictionary == null)
        {
            dictionary = new Dictionary<T, T>();
            dictionaries.SetValue(dictionary);
        }
        dictionary[original] = clone;
    }

    public bool TryGetClone<T>(T original, out T clone)
    {
        var dictionary = dictionaries.GetValue<Dictionary<T, T>>();
        return dictionary.TryGetValue(original, out clone);
    }
}