如果键不存在，则使用setter的C＃自定义词典类型

Question

I am trying to define a custom type which extends the DIctionary with only one difference. when I set a value like this:

myCustomDic[3.5] = 4.0;

it first checks if the key 3.5 exists. if it does, sets the value to the new one. otherwise it adds the key with the new value. I did it like this:

class Dic : Dictionary<double, double>
    {
        private readonly Dictionary<double, double> _property;
        public Dic(Dictionary<double, double> property)
        {
            _property = property;
        }
        //Indexer: 
        public new double this[double CA]
        {
            get
            {
                return _property[CA];
            }
            set
            {
                if (_property.ContainsKey(CA))
                {
                    _property[CA] = value;
                }
                else
                {
                    _property.Add(CA, value);
                }
            }
        }
    }

and I use it like this:

var testDic = new Dic(new Dictionary<double, double>());
testDic[2.5] = 4.0;

However there is no key and value pair added to testDic? could somebody please tell why?

Answer 1

Because you are subclassing Dictionary , you don't need your own private Dictionary as well. Also, the behaviour you describe is how Dictionary already works, so you don't need to create your own class at all:

var t2 = new Dictionary<double, double>();

t2[2.5] = 4.0;
Console.WriteLine(t2[2.5]);  // outputs 4
t2[2.5] = 8.0;
Console.WriteLine(t2[2.5]);  // outputs 8

From the documentation at Dictionary<TKey, TValue>.Item Property (TKey) :

When you set the property value, if the key is in the Dictionary, the value associated with that key is replaced by the assigned value. If the key is not in the Dictionary, the key and value are added to the dictionary.

But you can:

class Dic : Dictionary<double, double> {
    //Indexer: 
    public new double this[double CA] {
        get => (this as Dictionary<double, double>)[CA];
        set {
            var parent = this as Dictionary<double, double>;
            if (parent.ContainsKey(CA))
                parent[CA] = value;
            else
                parent.Add(CA, value);
        }
    }
}

Then you can do:

var testDic = new Dic();

testDic[2.5] = 4.0;
Console.WriteLine(testDic[2.5]); // this outputs 4
testDic[2.5] = 8.0;
Console.WriteLine(testDic[2.5]);  // this outputs 8

Answer 2

This is because you check the Count property which remains zero because you did not overwrite it.

The count of your _property will increase but not the external one.

The debugger visualizer will still call the original Dictionary count which will still report 0 but if you print it to console it will work.

I still do not understand why you derive from the Dictionary because the way you describe your requirement is already implemented by the Dictionary.

public TValue this[TKey key]
{
    get
    {
        int num = this.FindEntry(key);
        if (num >= 0)
        {
            return this.entries[num].value;
        }
        ThrowHelper.ThrowKeyNotFoundException();
        return default(TValue);
    }
    set
    {
        this.Insert(key, value, false);
    }
}