Question

我找不到如何正确封装词典的完整示例。我需要/想要做的就是'覆盖'我知道无法覆盖的Add方法，因为它不是虚拟的。根据一些研究，我发现我需要使用私有字典封装它并实现IDictionary接口。

我能找到的最完整的例子是here，我主要是复制粘贴并猜到了不匹配的东西（该示例实现了一个只读字典，而我想要完整的默认功能一个自定义的Add（）方法）。

以下完整可编辑代码：

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Diagnostics;
using System.Runtime.InteropServices;
using System.Threading;

namespace IDictionary
{
    class Program
    {
        static void Main(string[] args)
        {
            Registers<string, dynamic> DynRegistry = new Registers<string, dynamic>();

            DynRegistry.Add("Foo", 100);
            Console.WriteLine("DynRegistry Size: {0}", DynRegistry.Count);
            foreach (var item in DynRegistry)
            {
                Console.WriteLine("\tName: {0}, Value: {1}", item.Key, item.Value);
            }
            DynRegistry.Add("Foo2", "Hello World");
            Console.WriteLine("DynRegistry Size: {0}", DynRegistry.Count);
            foreach (var item in DynRegistry)
            {
                Console.WriteLine("\tName: {0}, Value: {1}", item.Key, item.Value);
            }
            DynRegistry.Add("Foo", true);
            Console.WriteLine("DynRegistry Size: {0}\r\n", DynRegistry.Count);
            foreach (var item in DynRegistry)
            {
                Console.WriteLine("\tName: {0}, Value: {1}", item.Key, item.Value);
            }
            Console.ReadKey();
        }
    }

    class Registers<TKey, TValue> : IDictionary<TKey, TValue>,  ICollection
    {
        //Fields
        private Dictionary<TKey, TValue> source;
        private object syncRoot;

        //Constructor
                    public Registers()
    {
        this.source = new Dictionary<TKey, TValue>();
    }

        //Wrapped Methods
                                                public void Add(TKey key, TValue value)
    {
        if (this.source.ContainsKey(key))
        {
            this.source[key] = value;
        }
        else
        {
            this.source.Add(key, value);
        }
    }

        //Implement default Interfaces
                        void ICollection<KeyValuePair<TKey, TValue>>.CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex)
    {
        ICollection<KeyValuePair<TKey, TValue>> collection = this.source;
        collection.CopyTo(array, arrayIndex);
    }
        public int Count { get { return this.source.Count; } }
        public ICollection<TKey> Keys { get { return this.source.Keys; } }
        public ICollection<TValue> Values { get { return this.source.Values; } }
        bool ICollection<KeyValuePair<TKey, TValue>>.IsReadOnly { get { return false; } }
        bool ICollection.IsSynchronized { get { return false; } }
        object ICollection.SyncRoot
    {
        get
        {
            if (this.syncRoot == null)
            {
                ICollection collection = this.source as ICollection;

                if (collection != null)
                {
                    this.syncRoot = collection.SyncRoot;
                }
                else
                {
                    Interlocked.CompareExchange(ref this.syncRoot, new object(), null);
                }
            }
            return this.syncRoot;
        }
    }
        public TValue this[TKey key]
    {
        get { return this.source[key]; }
        set { this.source[key] = value; }
    }
        public bool ContainsKey(TKey key) { return this.source.ContainsKey(key); }
        public bool Remove(TKey key) { return this.source.Remove(key); }
        public bool TryGetValue(TKey key, out TValue value) { return this.source.TryGetValue(key, out value); }
        void ICollection<KeyValuePair<TKey, TValue>>.Add(KeyValuePair<TKey, TValue> item)
    {
        ICollection<KeyValuePair<TKey, TValue>> collection = this.source;
        collection.Add(item);
    }
        void ICollection<KeyValuePair<TKey, TValue>>.Clear()
    {
        ICollection<KeyValuePair<TKey, TValue>> collection = this.source;
        collection.Clear();
    }
        bool ICollection<KeyValuePair<TKey, TValue>>.Contains(KeyValuePair<TKey, TValue> item)
    {
        ICollection<KeyValuePair<TKey, TValue>> collection = this.source;
        return collection.Contains(item);
    }
        bool ICollection<KeyValuePair<TKey, TValue>>.Remove(KeyValuePair<TKey, TValue> item)
    {
        ICollection<KeyValuePair<TKey, TValue>> collection = this.source;
        return collection.Remove(item);
    }
        void ICollection.CopyTo(Array array, int index)
    {
        ICollection collection = new List<KeyValuePair<TKey, TValue>>(this.source);
        collection.CopyTo(array, index);
    }
        IEnumerator<KeyValuePair<TKey, TValue>> IEnumerable<KeyValuePair<TKey, TValue>>.GetEnumerator()
    {
        IEnumerable<KeyValuePair<TKey, TValue>> enumerator = this.source;
        return enumerator.GetEnumerator();
    }
        IEnumerator IEnumerable.GetEnumerator()
    {
        return this.source.GetEnumerator();
    }
    }
}

我发布这个的两个原因：

因此，任何需要这样做的人都不需要花30分钟重新输入冗余代码。
关于我是否正确完成此操作的反馈。我很困惑是否/为什么我需要实现ICollection接口（即。普通字典是否执行此操作，或者IDictionary是否具有字典功能的完整补充而无需ICollection）。

我真正需要的只是一个普通的Dictionary，其中Add方法执行AddOrReplace（）而不是Add（或因为Key已经存在而崩溃）。实现这一目标所需的工作似乎有点矫枉过正。

Answer 1

您可以使用

dict[key]=value

add or replace如果这就是你想要的全部。所以不需要包装字典。

使用IDictionary接口封装字典而不是覆盖或隐藏方法

1 个答案: