Question

I’m looking for a collection.

I need to be able to add elements as if using a 2D integer key, for example .Add(3, 4, element). If I add outside the range of the collection I need the collection to expand, this include negatively, although it can have a limit, for example the range of an Int16 would be good. Every element in the collection can have the same type as each other but I need to specify what that is, for example Set<type> s;

I also need to avoid slow operations such as searching when looking up an element, performance is less important when adding to the collection.

Does anyone have any ideas about what approach to use or best could provide the class in there answer.

Answer 1

If you want a compound key, you can use the Tuple<T1,T2> class in a : Dictionary<Tuple<T1,T2>, TItem>.

var coll = new Dictionary<Tuple<int,int>, AnyClass>();
coll.Add(new Tuple<int,int>(2, 3), new AnyClass("foo"));
coll.Add(new Tuple<int,int>(4, 2), new AnyClass("bar"));

var foo = coll[new Tuple<int,int>(2,3)];
var bar = coll[new Tuple<int,int>(4,2)];

If the syntax is too weird, you may wrap the class like this :

public class Dictionary2d<TKey1, TKey2, TItem> : Dictionary<Tuple<TKey1, TKey2>,TItem>
{
    public void Add(TKey1 k1, TKey2, TItem item) {
        this.Add(Tuple.Create(k1,k2), item);
    }

    public TItem this[TKey1 k1, TKey2 k2] {
        get { return this[Tuple.Create(k1,k2)]; }
    }
}

public class Program
{
    static void Main() {
        var coll = new Dictionary2d<int,int, AnyClass>();
        coll.Add(2, 3, new AnyClass("foo"));
        coll.Add(4, 2, new AnyClass("bar"));

        var foo = coll[2,3];
        var bar = coll[4,2];
    }
}

The benefits of using Tuple class, is that the equality and hashcode comparison is natively handled, so even if it’s a class, two differents instances of tuple with same values will be considered equals.