定制Dictionary

在日常开发中，经常会碰到对Dictionary的大量操作，判断等。当然可以用Dictionary本省，也可以重写一个符合自己逻辑处理的Dictionary.

public class MyDictionary<TKey, TValue> : IDictionary<TKey, TValue>
    {
        IList<TKey> keys = new List<TKey>();
        IList<TValue> values = new List<TValue>();

        public MyDictionary() 
        {
        }

        public MyDictionary(IDictionary<TKey, TValue> dictionary)
        {
            foreach (var key in dictionary.Keys)
            {
                this[(TKey)key] = (TValue)dictionary[key];
            }
        }

        public ICollection<TKey> keySet()
        {
            return this.Keys;
        }

        public bool IsEmpty()
        {
            return (this.Count == 0);
        }

        #region MyDictionary<TKey,TValue> Members

        public void Add(TKey key, TValue value)
        {
            keys.Add(key);
            values.Add(value);
        }

        public bool ContainsKey(TKey key)
        {
            return keys.Contains(key);
        }

        public ICollection<TKey> Keys
        {
            get { return new ReadOnlyCollection<TKey>(keys); }
        }

        public bool Remove(TKey key)
        {
            int removeLocation = keys.IndexOf(key);
            if (removeLocation < 0)
                return false;

            values.RemoveAt(removeLocation);
            keys.RemoveAt(removeLocation);
            return true;
        }

        public bool TryGetValue(TKey key, out TValue value)
        {
            if (keys.Contains(key))
            {
                value = values[keys.IndexOf(key)];
                return true;
            }
            value = default(TValue);
            return false;
        }

        public ICollection<TValue> Values
        {
            get { return new ReadOnlyCollection<TValue>(values); }
        }

        public TValue this[TKey key]
        {
            get
            {
                if (values.Count <= 0)
                    return default(TValue);
                else
                {
                    int nIndex = keys.IndexOf(key);
                    if (nIndex < 0)
                        return default(TValue);
                    else
                        return values[nIndex];
                }
            }
            set
            {
                if (keys.Contains(key))
                    values[keys.IndexOf(key)] = value;
                else
                    Add(key, value);
            }
        }

        #endregion

        #region ICollection<KeyValuePair<TKey,TValue>> Members

        public void Add(KeyValuePair<TKey, TValue> item)
        {
            Add(item.Key, item.Value);
        }

        public void Clear()
        {
            keys.Clear();
            values.Clear();
        }

        public bool Contains(KeyValuePair<TKey, TValue> item)
        {
            if (keys.Contains(item.Key))
                return (this[item.Key].Equals(item.Value));
            return false;
        }

        public void CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex)
        {
            if (array == null)
            {
                throw new ArgumentNullException("array was null");
            }
            if ((arrayIndex < 0) || (arrayIndex > array.Length))
            {
                throw new ArgumentOutOfRangeException("arrayIndex");
            }
            if ((array.Length - arrayIndex) < this.Count)
            {
                throw new ArgumentException("Array plus offset is too small");
            }

            foreach (KeyValuePair<TKey, TValue> keyValue in this)
            {
                array[arrayIndex++] = keyValue;
            }

        }

        public int Count
        {
            get { return keys.Count; }
        }

        public bool IsReadOnly
        {
            get { return false; }
        }

        public bool Remove(KeyValuePair<TKey, TValue> item)
        {
            if (keys.Contains(item.Key) && values[keys.IndexOf(item.Key)].Equals(item.Value))
            {
                Remove(item.Key);
                return true;
            }
            return false;
        }

        #endregion

        #region IEnumerable<KeyValuePair<TKey,TValue>> Members

        public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()
        {
            int index = 0;
            foreach (TKey key in keys)
                yield return new KeyValuePair<TKey, TValue>(key, values[index++]);
        }

        #endregion

        #region IEnumerable Members

        IEnumerator System.Collections.IEnumerable.GetEnumerator()
        {
            return this.Keys.GetEnumerator();
        }

        #endregion
    }