Question

I essentially want to do this:

if(obj is IDictionary)
{
    return "{" + string.Join(Environment.NewLine, ((IDictionary)obj).Cast<DictionaryEntry>().Select(e => string.Format("  {0}: {1}", PrettyString(e.Key), PrettyString(e.Value)))) + "}";
}

But I keep getting an invalid cast. I can do

foreach(DictionaryEntry e in (IDictionary)obj)

So why can’t I do this?

---

I find this quite curious. I wrote an extension to solve the problem:

static class EnumerableExt
{
    public static IEnumerable<DictionaryEntry> Entries(this IDictionary dict)
    {
        foreach (var item in dict) yield return (DictionaryEntry)item;
    }
}

Then I can just do:

((IDictionary)obj).Entries().Select(...)

The curious part is that Resharper tells me I can replace my extension with this:

return dict.Cast<DictionaryEntry>();

But that throws an exception. Is this a bug in Resharper? Or how Cast works? I’d imagine Cast would work exactly the way my extension does.

Edit: Ah.. I read this answer a bit more closely. Still strange.

Answer 1

Are the key and value types known at compile time? If so, you could make a generic method for the pretty-print and let the compiler infer the types for you, like:

static void Main(string[] args)
{
    var obj = new Dictionary<string, string>()
        {
            { "foo", "bar" },
            { "baz", "ack" },
        };

    var stringVersion = GetStringVersion(obj);

    Console.WriteLine(stringVersion);
}

private static string GetStringVersion<TKey, TValue>(Dictionary<TKey, TValue> dict)
{
    return "{" + string.Join(Environment.NewLine, dict.Select(e => string.Format("  {0}: {1}", e.Key, e.Value))) + "}";
}

In terms of the behavior you’re seeing, it’s a known weird case due to backwards compat and a design decision:

http://blogs.msdn.com/b/bclteam/archive/2004/09/03/225473.aspx

We discussed a problem with implementation of IEnumerable on
Dictionary. What type should IEnumerable.GetEnumerator().Current
return? KeyValuePair or DictionaryEntry? Same for
ICollection.CopyTo. Instances of what type should be copied to the
array?

We decided the following:

1. IEnumerable and ICollection interface implementations will use KeyValuePair<K,V> as the item type.
2. IDictionary specific members (GetEnumerator returning IDictionaryEnumerator) will use DictionaryEntry as the item type.

The reason is that we are in a process of making a change where IEnumerator<T> would extend IEnumerator. It would be very strange if walking the hierarchy from Dictionary<K,V>->IEnumerable<T>->IEnumerable we suddenly changed the type of the item returned from enumerators.

Due to that design decision (during the creation of .NET 2.0), when you operate on the non-generic IEnumerable, the GetEnumerator() call returns IDictionaryEnumerator, and the resulting items are of type DictionaryEntry (presumably for back-compat with Hashtable-type iteration). However, once you are calling the generic IEnumerable (which is what happens once you do Cast() or OfType(), you’ll get KeyValuePair items instead.

Note that this is a particular oddity about using Dictionary in a non-generic context – Hashtable (still) iterates as DictionaryEntry items just fine, and ‘normal’ iteration over Dictionary gives you KeyValuePair items.

As others have said, you should stick with the generic access if you can, since it’ll let you avoid this little ‘gotcha’ in the design decisions of Dictionary.