修改字典中的添加：重新实现IDictionary vs继承自Dictionary

Question

So let's say that I need to redefine Add in my Dictionary<string, string> .

Solution A:

public class ImplementedDict : IDictionary<string, string>
{
    private readonly Dictionary<string, string> _data = new Dictionary<string, string>();
    public void Add(string key, string value)
    {
        _data.Add(key, value);
    }
}

Solution B:

public class InheritedDict : Dictionary<string, string>
{
    public override void Add(string key, string value)
    {
        base.Add(key, value);
    }
}

Another StackOverflow user was telling me (in another thread's comments section) that solution A is the right one. Which is the contrary of what I expected.

Apparently it is because "Add isn't a virtual method". He was pointing me to the documentation: https://msdn.microsoft.com/en-us/library/k7z0zy8k(v=vs.110).aspx

I confess that I still don't get it.

Edit : so the question is: why would solution B be considered bad code? (sorry, @Backs's answer made sense when I wrongly asked "why would solution A be considered bad code?")

Answer 1

When you shadow a method, if the client code calls the method with instance typed as base class, then your method will not be called. It will call base class method.

This is the main reason why you're suggested to use method1.

For example:

Dictionary<string, string> dic = new InheritedDict();
dic.Add("key","value");//Will not call your method.

If the Add method was declared virtual(it isn't), you could have overridden the Add method. In that case it will call the derived class method as you expect.

Answer 2

Short - No reason :) I don't see problems. You have your own implementation of IDictionary. It's ok.

Answer 3

Yet another possibility is an extension method :

  public static DictionaryExtensions {
    public static void MyAdd(this Dictionary<string, string> dictionary, String key, String value) {
      ...
    }
  } 

So you can use existing Dictionary<String, String> implementation (Microsoft) with extended functionality:

  Dictionary<string, string> dict = new Dictionary<string, string>();
  ...
  dict.MyAdd("myKey", "SomeValue");

Answer 4

You can think of it as each implemented interface has its own virtual method table .

Still Dictionary.Add is not virtual you can't call inheritor's implementation:

Dictionary<string, string> d = new InheritedDict<string, string>(); // Ok, you can do it
d.Add("foo", "bar"); // Wrong! You can, but Dictionary.Add will be called

But:

public class InheritedDict : Dictionary<string, string>
{
    void IDictionary<string, string>.Add(string key, string value)
    {
        base.Add(key, value);
    }
}

Dictionary<string, string> d = new InheritedDict<string, string>();
var d2 = d as IDictionary<string, string>;
d2.Add("foo", "bar"); // Ok

Second way is a difficult, right?

So it's better implement entire interface IDictionary instead of overriding the single method of Dictionary . Therefore, although the solution A is a little bit verbose, but it's absolutely correct.