Enable foreach for a class derived from Dictionary

Question

Hi folks,

I have a class derived from Dictionary. I need this class to simulate a HashSet, because Silverlight doesn't know HashSets and my classes make heavy use of HashSets. So I decided to exchange the HashSet with Dictionary. To further use my classes with all the HashSet-Objects, I try to make a custom HashSet class, that is derived from Dictionary and override all the relavant methods like the Add-method:

class HashSet<T> : Dictionary<T, object>
{

    public override void Add(T element)
    {
     base.Add(element, null);
    }
}

Now I need to enable the foreach-loop for my new HashSet-class. Obviously, my class returns a KeyValuePair in a foreach-loop, but I need T as return type. Can anyone tell me, what and how I need to override the Dictionary base class?

Thanks in advance, Frank

Answer 1

I would strongly suggest that you don't derive from Dictionary in the first place. Use composition instead of inheritance. If you derive from Dictionary, people can use your class as a dictionary of key/value pairs instead of as a set.

So, you design your class with a dictionary inside it:

public sealed class DictionaryBackedSet<T> : IEnumerable<T>
{
    private readonly Dictionary<T, int> dictionary = new Dictionary<T, int>();

    public IEnumerator<T> GetEnumerator()
    {
        return dictionary.Keys;
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }

    public bool Add(T item)
    {
        if (Contains(item))
        {
            return false;
        }
        dictionary.Add(item, 0);
        return true;
    }

    public bool Contains(T item)
    {
        return dictionary.ContainsKey(item);
    }

    // etc
}

You might also want to create an empty struct as the value type argument for the dictionary:

public struct Empty {}

That may save a little memory. I wouldn't worry about it for now though - and if you compose the dictionary instead of inheriting from it, making that change later won't break anything :)

It would be nice if you could use System.Void for this purpose (i.e. use Dictionary<T, Void>), but C# won't let you do that :(

Answer 2

I think you would need to implement IEnumerable(Of T), which would internally work with the Keys collection.

IDictionary already implements IEnumerable(Of KeyValuePair(Of TKey, TValue)), but perhaps it's possible to implement it for another type as well?

I'm with Jon re trying to subclass Dictionary--avoid if you can, composition is a much more appropriate design pattern.

Answer 3

I suggest that rather than inheriting from Dictionary you wrap it. A HashSet is not a Dictionary.