How can I make a type safe bag of items that all implement a generic interface?

Question

Need to have a type-safe bag of items that all implement a generic interface.

The desire is to do something like:

var stringItem = new IItem<string>();
var numberItem = new IItem<int>();
var items = new List<IItem<T>>(); //T of course doesn't accomplish what I want

items.Add(stringItem);
items.Add(numberItem);

Something like:

interface IItem
{
   object Value { get; set; }
}

//Update: 2009-03-19 03:08 PM MST
//Added the following interface for clarity of my question

interface IItem<T> : IItem
{
   new T Value { get; set; }
}

Then, I could:

var items = new List<IItem>();

But, I lose type safety in my bag. So, I thought of Dictionary:

var dict = new Dictionary<Type, List<IItem<T>>>(); //T is wrong again

dict.Add(typeof(string), new List<IItem<string>>); //that sure looks nice

Answer 1

I was thinking about exactly this same problem a few weeks ago. Think about what you're trying to do: store different types in the same collection. Even generics aren't going to help you out here.

The only solution (that I know of) is to use List<Object> and cast when you pull the items out.

Answer 2

Check out the PolyDictionary implementation here.

class Key<T> { public Key() { } }

class PolyDictionary {
    private Dictionary<object, object> _table;

    public PolyDictionary() {
        _table = new Dictionary<object, object>();
    }

    public void Add<T>(Key<T> key, T value) {
        _table.Add(key, value);
    }

    public bool Contains<T>(Key<T> key) {
        return _table.ContainsKey(key);
    }

    public void Remove<T>(Key<T> key) {
        _table.Remove(key);
    }

    public bool TryGetValue<T>(Key<T> key, out T value) {
        object objValue;
        if (_table.TryGetValue(key, out objValue)) {
            value = (T)objValue;
            return true;
        }
        value = default(T);
        return false;
    }

    public T Get<T>(Key<T> key) {
        T value;
        if (!TryGetValue(key, out value))
            throw new KeyNotFoundException();
        return value;
    }

    public void Set<T>(Key<T> key, T value) {
        _table[key] = value;
    }
}

Answer 3

You should be able to get away with doing something like the following

interface IItem { object Value {get; set;}}

interface IItem<T> : IItem { T Value {get; set;}}

var items = new List<IItem>();

items.add(new IItem<string>());
items.add(new IItem<int>());

But you'll still have to do some casting when you pull it out.

Answer 4

I don't think you can escape the fact that IItem<int> and IItem<string> are different; the usual approach is a base-interface:

interface IItem {
   object Value {get;}
}
interface IItem<T> : IItem {
   new T Value {get;}
}

That way, you code against IItem, but the actual instances (that typically implement IItem<T> for some T) are stll strongly-typed internally.

Answer 5

Make a new class which has the sole purpose of boxing the values you are interested in. - This class should accept either a StringItem, OR a NumberItem. - The class should allow you access to the string or number item member.

WHen you a dd your objects to the list, you will need to box your objects, and then unbox them when you take them out again.

If this was C++, then the overhead of this design should not be more than an additional pointer dereference, depending on how you implement it, however the key phrases here are "boxing" and "unboxing".

Answer 6

public class GrabBag<T>
{
    private ArrayList inner = new ArrayList();

    public void Add(T item)
    {
        inner.Add(item);
    }

    public IEnumerable<U> Get<U>() where U : T
    {
        return inner.OfType<U>();
    }
}

Or, you could just use the generic List and call OfType. That makes more sense.