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];
            }
        }

    }
}
--------------------- 
作者：xiaogoudiandeng 
来源：CSDN 
原文：https://blog.csdn.net/xiaogoudiandeng/article/details/54176311 
版权声明：本文为博主原创文章，转载请附上博文链接！