c# How to put all dictionary into an object of derived type from Dictionary?

Question

class XDictionary<TKey, TValue> : Dictionary<string, string>
{
}

        Dictionary<string, string> d = new Dictionary<string, string>
        {
            { "x", "xx" },
            { "y", "yy" },
            { "z", "zz" }
        };

        XDictionary<string, string> x;

Is there a way to put d in x without a foreach, just using upcasting/dowcasting?

short answer. No. And in any case you probably dont want to inherit from the dictionary. Your class should be composed of a dictionary and then you take a constructor which is the seed dictionary. You can make it implement `IDictionary` if you want your class to behave like a dictionary — Jamiec, Aug 13 '20 at 14:09
in fact upcasting is never needed(as you can always use derived type as base type) and with downcast instance have to be the type of downcast anyway (you cannot downcast `new object()` to `string` but you can `object s = "";` because it's string anyway) — Selvin, Aug 13 '20 at 14:10
What you have described here is most likely an [XY Problem](http://xyproblem.info/). If you explain what you're trying to achieve, there is almost certainly a better way. My earlier comment is a good stab at X, not answering Y! — Jamiec, Aug 13 '20 at 14:16
... of course .. you may overload [cast operator](https://learn.microsoft.com/en-US/dotnet/csharp/language-reference/language-specification/conversions#explicit-dynamic-conversions) but still you have to use "foreach" in implementation and ... it will be annoying for future code readers — Selvin, Aug 13 '20 at 14:17
Actually, `Dictionary` has a constructor you can just forward to. You cannot use a cast because you cannot define a conversion between two types if one inherits from the other. However, as already stated by others, do not extend `Dictionary`, implement `IDictionary`, and delegate if you need such functionality. — Aluan Haddad, Aug 13 '20 at 14:18
you shouldn´t inherit from `Dictionary` for the exact same reasons you [shouldn´t do so for a `List`](https://stackoverflow.com/questions/21692193/why-not-inherit-from-listt) — MakePeaceGreatAgain, Aug 13 '20 at 14:30
Thx all for answers. I will make a class composed of a dictionary like @Jamiec sugested — Costea Voda, Aug 13 '20 at 15:16
Dear God, I wish the BCL designers had made List and Dictionary sealed. — Ian Kemp, Aug 13 '20 at 15:16
@HimBromBeere that thread is not applicable here, because it is about a class 'FootballTeam' inheriting from a List. He is presenting an empty class 'xDictionary' that inherits from 'Dictionary', so you can assume it is going to be an extended dictionary, rather than something else. — Purity, Aug 13 '20 at 16:23

Purity · Answer 1 · 2020-08-14T03:16:13.267

First of all, the reason you would have to iterate through the items (which is not a problem), is because you want to copy them.

If you'd just reference the dictionary as new internal representation, you would have multiple objects working on the same data.

This has nothing to do with you inheriting from it though - when you create a new Dictionary from another Dictionary (instead of xDictionary) - you would want the same thing.

As for the downcast - that is generally not possible, unless the type you are casting to matches the runtime-type itself or anything in the hierarchy between them.

So you won't get around it being iterated somehow, but you can pass it to the base-copy-constructor that already implemented this:

class XDictionary<TKey, TValue> : Dictionary<TKey, TValue>
{
    public XDictionary() { }
    public XDictionary(IDictionary<TKey, TValue> dict) : base(dict) { }
}

Dictionary<string, string> d = new Dictionary<string, string>
{
    { "x", "xx" },
    { "y", "yy" },
    { "z", "zz" }
};

XDictionary<string, string> xDict = new XDictionary<string, string>(d);

Note also when you are declaring generic type-parameters for your class, you have to forward them to your base-class in order for it to make sense.

I do disagree with some of the comments below your question.

There is a guideline saying prefer composition over inheritance, which does have it's reasons. However, being dogmatic about it is not helpful, since with composition:

You do have to write a lot more code to truly achieve the same base functionality.
You have an additional object scattered over the heap.

So if your intention is not to change the Dictionary to something else - but rather extend it's functionality - inheriting from it is absolutely fine.

You can ask yourself this question for clarity:

Is my implementation supposed to be some kind of dictionary (inheritance), or to use a dictionary (composition).

There are a few things to be aware of when using inheritance, but when you are not changing the internal representation and equality/comparison mechanisms in any way, you are good for now.

If you want to modify the dictionary a bit more and not just extend it, do also consider using System.Collections.DictionaryBase as your base class.

This abstract class will still do most of the heavy lifting for you, but provide more freedom for your implementation through abstraction.

c# How to put all dictionary into an object of derived type from Dictionary?

1 Answers1