C#实现自定义Dictionary类实例

这里是C#实现自定义Dictionary类实例的完整攻略：

1. 创建自定义Dictionary类

首先，我们需要创建一个自定义的Dictionary类，我们可以参考.NET Framework中原有的Dictionary类的实现方式，但是需要添加一些自定义的功能。下面是一个基本的实现方式：

public class MyDictionary<TKey, TValue>
{
    private List<KeyValuePair<TKey, TValue>> _list;

    public MyDictionary()
    {
        _list = new List<KeyValuePair<TKey, TValue>>();
    }

    public void Add(TKey key, TValue value)
    {
        _list.Add(new KeyValuePair<TKey, TValue>(key, value));
    }

    public bool ContainsKey(TKey key)
    {
        foreach (var pair in _list)
        {
            if (pair.Key.Equals(key))
            {
                return true;
            }
        }
        return false;
    }

    public TValue this[TKey key]
    {
        get
        {
            foreach (var pair in _list)
            {
                if (pair.Key.Equals(key))
                {
                    return pair.Value;
                }
            }
            throw new KeyNotFoundException();
        }
        set
        {
            for (int i = 0; i < _list.Count; i++)
            {
                if (_list[i].Key.Equals(key))
                {
                    _list[i] = new KeyValuePair<TKey, TValue>(key, value);
                    return;
                }
            }
            Add(key, value);
        }
    }

    public bool Remove(TKey key)
    {
        for (int i = 0; i < _list.Count; i++)
        {
            if (_list[i].Key.Equals(key))
            {
                _list.RemoveAt(i);
                return true;
            }
        }
        return false;
    }
}

这个类实现了基本的添加、查找、修改和删除操作，但是性能方面并不是很优秀，需要进一步优化。

2. 使用自定义Dictionary类

我们可以创建一个MyDictionary类的实例，并使用它来存储一些键值对。下面是一个示例：

MyDictionary<int, string> dict = new MyDictionary<int, string>();
dict.Add(1, "apple");
dict.Add(2, "banana");
dict[3] = "orange";
Console.WriteLine(dict[1]);  // apple
Console.WriteLine(dict[2]);  // banana
Console.WriteLine(dict[3]);  // orange
dict.Remove(2);
Console.WriteLine(dict.ContainsKey(2));  // false

在示例中，我们首先创建了一个MyDictionary类型的对象，并添加了3个键值对。然后我们使用方括号访问索引号为1、2和3的元素，并输出它们的值。接着我们从字典中删除了键值为2的元素，并使用ContainsKey方法判断字典中是否包含键2，输出结果为false。

3. 优化自定义Dictionary类

在MyDictionary类中，我们采用了List>来存储数据，虽然这样实现简单，但对于大量数据的存储和查找还是效率比较低的。我们可以考虑采用更加高效的方式来实现自定义Dictionary类。

public class MyDictionary<TKey, TValue>
{
    private const int _size = 100;
    private LinkedList<KeyValuePair<TKey, TValue>>[] _items = new LinkedList<KeyValuePair<TKey, TValue>>[_size];

    private int GetIndex(TKey key)
    {
        int hash = key.GetHashCode();
        int index = Math.Abs(hash % _size);
        return index;
    }

    public void Add(TKey key, TValue value)
    {
        int index = GetIndex(key);
        if (_items[index] == null)
        {
            _items[index] = new LinkedList<KeyValuePair<TKey, TValue>>();
        }

        foreach (var pair in _items[index])
        {
            if (pair.Key.Equals(key))
            {
                throw new ArgumentException("An element with the same key already exists in the dictionary.");
            }
        }

        _items[index].AddFirst(new KeyValuePair<TKey, TValue>(key, value));
    }

    public bool ContainsKey(TKey key)
    {
        int index = GetIndex(key);

        if (_items[index] == null)
        {
            return false;
        }

        foreach (var pair in _items[index])
        {
            if (pair.Key.Equals(key))
            {
                return true;
            }
        }

        return false;
    }

    public TValue this[TKey key]
    {
        get
        {
            int index = GetIndex(key);
            if (_items[index] == null)
            {
                throw new KeyNotFoundException();
            }

            foreach (var pair in _items[index])
            {
                if (pair.Key.Equals(key))
                {
                    return pair.Value;
                }
            }

            throw new KeyNotFoundException();
        }
        set
        {
            int index = GetIndex(key);
            if (_items[index] == null)
            {
                _items[index] = new LinkedList<KeyValuePair<TKey, TValue>>();
            }

            bool keyExists = false;
            LinkedListNode<KeyValuePair<TKey, TValue>> node = null;

            foreach (var pair in _items[index])
            {
                if (pair.Key.Equals(key))
                {
                    keyExists = true;
                    node = pair;
                    break;
                }
            }

            if (keyExists)
            {
                _items[index].Remove(node);
            }

            _items[index].AddFirst(new KeyValuePair<TKey, TValue>(key, value));
        }
    }

    public bool Remove(TKey key)
    {
        int index = GetIndex(key);

        if (_items[index] == null)
        {
            return false;
        }

        foreach (var pair in _items[index])
        {
            if (pair.Key.Equals(key))
            {
                _items[index].Remove(pair);
                return true;
            }
        }

        return false;
    }
}

在优化后的MyDictionary类中，我们使用了构造一个长度为100的数组来存储键值对，为了让存储的数据更加均匀，我们使用key.GetHashCode()方法生成一个哈希码，并使用哈希码对100取余数来得到对应的索引。对于同一个哈希码，我们使用链表来实现存储，这样即使出现哈希码冲突的情况，也不会影响到性能。

下面是一个优化后的示例：

MyDictionary<int, string> dict = new MyDictionary<int, string>();
dict.Add(1, "apple");
dict.Add(2, "banana");
dict[3] = "orange";
Console.WriteLine(dict[1]);  // apple
Console.WriteLine(dict[2]);  // banana
Console.WriteLine(dict[3]);  // orange
dict.Remove(2);
Console.WriteLine(dict.ContainsKey(2));  // false

在示例中，我们可以看到和之前的示例一样，但是优化后的MyDictionary类在存储数据和查找数据的性能方面得到了一定的提升。