线程安全的数据字典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
{
    ///

    /// 线程安全的数据字典
    ///

    ///
    ///
    public class SynchronizedDictionary
    {
        private Dictionary dic=new Dictionary();
        private object obj = new object();


        ///

        /// 向字典中增加键值对
        ///

        ///
        ///
        public void Add(TKey key, TValue value)
        {
            lock (obj)
            {
                if(ContainsKey(key))
                {
                    Remove(key);
                }
                dic.Add(key, value);
            }
        }


        ///

        /// 向字典中添加列表
        ///

        ///
        ///
        public void AddRange(ICollection valueList, Func 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);
                    }
                }
            }
        }


        ///

        /// 清空数据字典
        ///

        public void Clear()
        {
            lock (obj)
            {
                dic.Clear();
            }
        }


        ///

        /// 从字典中移除特定的键值对
        ///

        ///
        ///
        public bool Remove(TKey key)
        {
            lock (obj)
            {
                return dic.Remove(key);
            }
        }


        ///

        /// 字典是否包含特定的键
        ///

        ///
        ///
        public bool ContainsKey(TKey key)
        {
            lock (obj)
            {
                return dic.ContainsKey(key);
            }
        }
        
        ///

        /// 字典是否包含特定的值
        ///

        ///
        ///
        public bool ContainsValue(TValue value)
        {
            lock (obj)
            {
                return dic.ContainsValue(value);
            }
        }
        
        ///

        /// 字典中键值对的数目
        ///

        public int Count
        {
            get 
            {
                lock (obj)
                {
                    return dic.Count;
                }
            }
        }


        ///

        /// 字典的键集合
        ///

        public Dictionary.KeyCollection Keys
        {
            get
            {
                lock (obj)
                {
                    return dic.Keys;
                }
            }
        }


        ///

        /// 字典值集合
        ///

        public Dictionary.ValueCollection Values
        {
            get
            {
                lock (obj)
                {
                    return dic.Values;
                }
            }
        }


        ///

        /// 字典键数组
        ///

        public TKey[] KeysToArray
        {
            get
            {
                lock (obj)
                {
                    TKey[] keys = new TKey[dic.Keys.Count];
                    dic.Keys.CopyTo(keys, 0);
                    return keys;
                }
            }
        }


        ///

        /// 字典值数组
        ///

        public TValue[] ValuesToArray
        {
            get
            {
                lock (obj)
                {
                    TValue[] values = new TValue[dic.Keys.Count];
                    dic.Values.CopyTo(values, 0);
                    return values;
                }
            }
        }
                
        ///

        /// 返回字典循环访问的枚举
        ///

        ///
        public Dictionary.Enumerator GetEnumerator()
        {
            lock (obj)
            {
                return dic.GetEnumerator();
            }
        }
        
        ///

        /// 
        ///

        public IEqualityComparer Comparer
        {
            get
            {
                lock (obj)
                {
                    return dic.Comparer;
                }
            }
        }


        ///

        /// 通过key获取特定的值
        ///

        ///
        ///
        public TValue this[TKey key]
        {


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


        /////

        ///// 获取字典特定位置的值
        /////

        /////
        /////
        public TValue Value(int index)
        {


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


        ///

        /// 获取字典特定位置的键
        ///

        ///
        ///
        public TKey Key(int index)
        {


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


    }
}