线程安全的数据字典Dictionary

using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Security;
using System.Threading;


namespace Dictionary
{
    /// <summary>
    /// 线程安全的数据字典
    /// </summary>
    /// <typeparam name="TKey"></typeparam>
    /// <typeparam name="TValue"></typeparam>
    public class SynchronizedDictionary<TKey, TValue>
    {
        private Dictionary<TKey, TValue> dic=new Dictionary<TKey,TValue>();
        private object obj = new object();


        /// <summary>
        /// 向字典中增加键值对
        /// </summary>
        /// <param name="key"></param>
        /// <param name="value"></param>
        public void Add(TKey key, TValue value)
        {
            lock (obj)
            {
                if(ContainsKey(key))
                {
                    Remove(key);
                }
                dic.Add(key, value);
            }
        }


        /// <summary>
        /// 向字典中添加列表
        /// </summary>
        /// <param name="valueList"></param>
        /// <param name="func"></param>
        public void AddRange(ICollection<TValue> valueList, Func<TValue,TKey> func)
        {
            lock (obj)
            {
                if (func != null)
                {
                    TKey key = default(TKey);


                    foreach (var item in valueList)
                    {
                        key = func(item);
                        
                        if (ContainsKey(key))
                        {
                            dic.Remove(key);
                        }


                        dic.Add(key, item);


                        key = default(TKey);
                    }
                }
            }
        }


        /// <summary>
        /// 清空数据字典
        /// </summary>
        public void Clear()
        {
            lock (obj)
            {
                dic.Clear();
            }
        }


        /// <summary>
        /// 从字典中移除特定的键值对
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public bool Remove(TKey key)
        {
            lock (obj)
            {
                return dic.Remove(key);
            }
        }


        /// <summary>
        /// 字典是否包含特定的键
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public bool ContainsKey(TKey key)
        {
            lock (obj)
            {
                return dic.ContainsKey(key);
            }
        }
        
        /// <summary>
        /// 字典是否包含特定的值
        /// </summary>
        /// <param name="value"></param>
        /// <returns></returns>
        public bool ContainsValue(TValue value)
        {
            lock (obj)
            {
                return dic.ContainsValue(value);
            }
        }
        
        /// <summary>
        /// 字典中键值对的数目
        /// </summary>
        public int Count
        {
            get 
            {
                lock (obj)
                {
                    return dic.Count;
                }
            }
        }


        /// <summary>
        /// 字典的键集合
        /// </summary>
        public Dictionary<TKey, TValue>.KeyCollection Keys
        {
            get
            {
                lock (obj)
                {
                    return dic.Keys;
                }
            }
        }


        /// <summary>
        /// 字典值集合
        /// </summary>
        public Dictionary<TKey, TValue>.ValueCollection Values
        {
            get
            {
                lock (obj)
                {
                    return dic.Values;
                }
            }
        }


        /// <summary>
        /// 字典键数组
        /// </summary>
        public TKey[] KeysToArray
        {
            get
            {
                lock (obj)
                {
                    TKey[] keys = new TKey[dic.Keys.Count];
                    dic.Keys.CopyTo(keys, 0);
                    return keys;
                }
            }
        }


        /// <summary>
        /// 字典值数组
        /// </summary>
        public TValue[] ValuesToArray
        {
            get
            {
                lock (obj)
                {
                    TValue[] values = new TValue[dic.Keys.Count];
                    dic.Values.CopyTo(values, 0);
                    return values;
                }
            }
        }
                
        /// <summary>
        /// 返回字典循环访问的枚举
        /// </summary>
        /// <returns></returns>
        public Dictionary<TKey, TValue>.Enumerator GetEnumerator()
        {
            lock (obj)
            {
                return dic.GetEnumerator();
            }
        }
        
        /// <summary>
        /// 
        /// </summary>
        public IEqualityComparer<TKey> Comparer
        {
            get
            {
                lock (obj)
                {
                    return dic.Comparer;
                }
            }
        }


        /// <summary>
        /// 通过key获取特定的值
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public TValue this[TKey key]
        {


            get
            {
                lock (obj)
                {
                    return dic[key];
                }
            }
            set
            {
                lock (obj)
                {
                    dic[key] = value;
                }
            }
        }


        / <summary>
        / 获取字典特定位置的值
        / </summary>
        / <param name="index"></param>
        / <returns></returns>
        public TValue Value(int index)
        {


            lock (obj)
            {
                return ValuesToArray[index];
            }
        }


        /// <summary>
        /// 获取字典特定位置的键
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        public TKey Key(int index)
        {


            lock (obj)
            {
                return KeysToArray[index];
            }
        }


    }
}