厚积薄发，丰富的公用类库积累，助你高效进行系统开发（10）---各种线程同步的集合类

/// <summary>
///判断字典<see cref="System.Collections.Generic.Dictionary{TKey, TValue}"></see>是否包含指定的值。
/// </summary>
/// <param name="value">待判断的值,如果值为引用类型，则可以为null</param>
/// <returns>
///如果字典包含项目，则返回true，否则为false。
/// </returns>
public virtual bool ContainsValue(TValue value)

/// <summary>
///判断字典是否包含指定键的元素
/// </summary>
/// <param name="key">在字典中查找的键.</param>
/// <returns>
///如果字典中包含指定键的元素，返回true，否则为false
/// </returns>
/// <exception cref="System.ArgumentNullException">键为空</exception>
public virtual bool ContainsKey(TKey key)

/// <summary>
///在字典中添加一个元素，根据提供的键和值
/// </summary>
/// <param name="key">作为待添加元素的键</param>
/// <param name="value">作为待添加元素的值.</param>
/// <exception cref="System.NotSupportedException">字典对象为只读</exception>
/// <exception cref="System.ArgumentException">含有相同键的元素已经存在字典中</exception>
/// <exception cref="System.ArgumentNullException">键为空.</exception>
public virtual void Add(TKey key, TValue value)

/// <summary>
///在指定的索引插入元素
/// </summary>
/// <param name="index">插入位置，从零开始的索引</param>
/// <param name="key">作为待插入元素的键</param>
/// <param name="value">作为待插入元素的值</param>
/// <exception cref="T:System.NotSupportedException">集合为只读</exception>
/// <exception cref="T:System.ArgumentOutOfRangeException">指定索引在<see cref="T:System.Collections.Generic.IList`1"></see>中为无效索引.</exception>
public void Insert(int index, TKey key, TValue value)

/// <summary>
///获取指定键的元素索引
/// </summary>
/// <param name="key">待查找的键</param>
/// <returns>
///如果列表中发现则为项目的索引，否则为-1。
/// </returns>
public int IndexOf(TKey key)

/// <summary>
///获取指定键的元素索引
/// </summary>
/// <param name="value">待查找的键</param>
/// <returns>
///如果列表中发现则为项目的索引，否则为-1。
/// </returns>
public int IndexOf(TValue value)

/// <summary>
///获取或设置与指定键的值。
/// </summary>
public virtual TValue this[TKey key]

/// <summary>获取或设置指定索引相关联的值</summary>
/// <returns>返回指定索引中关联的值, 如果指定的索引为无效，获取或设置操作将抛出<see cref="ArgumentOutOfRangeException"></see>。
/// </returns>
/// <param name="index">获取或设置值的索引</param>
/// <exception cref="ArgumentOutOfRangeException">索引大于集合数量或者小于0</exception>
public virtual TValue this[int index]

/// <summary>
///复制集合元素到数组中, 以数组的索引开始.
/// </summary>
/// <param name="array">一维数组<see cref="System.Array"></see>，它是从集合中复制的目标。数组对象必须是从零开始的索引。</param>
/// <param name="arrayIndex">Array中的从零开始的索引，位于复制开始。</param>
/// <exception cref="System.ArgumentOutOfRangeException">arrayIndex 小于0</exception>
/// <exception cref="System.ArgumentNullException">array 为null</exception>
/// <exception cref="System.ArgumentException">
///数组为多维；或arrayIndex等于或大于数组的长度；
///或源集合中元素的数量大于arrayIndex到目标数组结束间可用空间。
///或者TKey的类型不能自动转换为目标数组的类型。</exception>
public virtual void CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex)

/// <summary>
///创建一个新的对象，它是当前实例的一个副本
/// </summary>
/// <returns>
///一个新的对象，此实例的一个副本。
/// </returns>
public OrderedDictionary<TKey, TValue> Clone()

OrderedDictionary<string, string> syncDict = new OrderedDictionary<string, string>();
syncDict.Add("A", "testA");
syncDict.Add("C", "testC");
syncDict.Add("B", "TestB");

//通过键访问
StringBuilder sb = new StringBuilder();
foreach (string key in syncDict.Keys)
{
sb.AppendFormat("{0}:{1}\r\n", key, syncDict[key]);
}
sb.AppendLine();

//通过索引访问
for (int i = 0; i < syncDict.Keys.Count; i++)
{
sb.AppendFormat("{0}:{1}\r\n", i, syncDict[i]);
}
MessageUtil.ShowTips(sb.ToString());  

//框架内置的排序字典
SortedDictionary<string, string> sortDict = new SortedDictionary<string, string>();
sortDict.Add("A", "testA");
sortDict.Add("C", "testC");
sortDict.Add("B", "TestB");

sb = new StringBuilder();
foreach (string key in sortDict.Keys)
{
sb.AppendFormat("{0}:{1}\r\n", key, sortDict[key]);
}
MessageUtil.ShowTips(sb.ToString());  

/// <summary>
///获取指定键的关联值
/// </summary>
/// <param name="key">字典键</param>
/// <param name="value">当此方法返回值时，如果找到该键，便会返回与指定的键相关联的值；否则，则会返回 value 参数的类型默认值。该参数未经初始化即被传递。</param>
/// <returns>如果字典对象包含具有指定键的元素，则为 true；否则为false.</returns>
public new bool TryGetValue(TKey key, out TValue value)

/// <summary>获取或设置指定键的值</summary>
/// <returns>与指定键关联的值。如果没有找到指定键，KeyNotFoundException将抛出，操作创建一个有指定键的新元素。</returns>
/// <param name="key">设定值的键</param>
/// <exception cref="System.ArgumentNullException">键位空</exception>
/// <exception cref="System.Collections.Generic.KeyNotFoundException">属性检索和键在集合不存在。</exception>
public new TValue this[TKey key]

/// <summary>获取字典对象的键集合</summary>
public new KeyCollection Keys

/// <summary>获取字典中值的对象集合</summary>
public new ValueCollection Values

/// <summary>获取<see cref="System.Collections.Generic.IEqualityComparer{TKey}"></see>对象，该对象用来比较字典表键的相等</summary>
/// <returns>对象<see cref="System.Collections.Generic.IEqualityComparer{TKey}"></see>通用接口，用来判断当前对象<see cref="T:System.Collections.Generic.Dictionary`2"></see>的相等性，
///并提供键的哈希值.</returns>
public new IEqualityComparer<TKey> Comparer

/// <summary>
///获取字典集合中包含键值对的数量
/// </summary>
/// <value></value>
/// <returns>字典集合中所含元素的数目</returns>
public new virtual int Count

/// <summary>在集合中移除指定键的元素</summary>
/// <returns>如果元素被移除返回true，否则为false。如果原始集合中没有发现指定键的元素，也返回false。</returns>
/// <param name="key">待移除元素的键</param>
/// <exception cref="System.ArgumentNullException">键为空</exception>
public new bool Remove(TKey key)

/// <summary>获取迭代结合的枚举器.</summary>
public new Enumerator GetEnumerator()

/// <summary>
///初始化SyncDictionary对象实例
/// </summary>
/// <param name="dictionary">字典对象</param>
public SyncDictionary(CDictionary<TKey, TValue> dictionary)

/// <summary>
///初始化SyncDictionary对象实例
/// </summary>
public SyncDictionary()

/// <summary>
///为字典表添加指定的键值
/// </summary>
/// <param name="key">待添加元素的键</param>
/// <param name="value">待添加元素的值. 该值可以是空引用类型.</param>
/// <exception cref="System.ArgumentException">一个具有相同键的元素已经存在于字典</exception>
/// <exception cref="System.ArgumentNullException">键为空</exception>
public new void Add(TKey key, TValue value)

/// <summary>
///获取一个值，指出对集合的存取是否同步（线程安全）
/// </summary>
/// <value>如果词典的访问是同步的（线程安全）则为True，否则为false。默认为false。</value>
public override bool IsSynchronized

/// <summary>
///从字典中移除所有的键值
/// </summary>
public new void Clear()

/// <summary>
///实现<see cref="System.Runtime.Serialization"></see>接口并返回需要序列化字典<see cref="System.Collections.Generic.Dictionary{TKey, TValue}"></see>实例的数据。
/// </summary>
/// <param name="info">一个 SerializationInfo 对象，它包含序列化Dictionary所需的信息。</param>
/// <param name="context">StreamingContext 结构，该结构包含与 Dictionary相关联的序列化流的源和目标。</param>
/// <exception cref="System.ArgumentNullException">info为空引用</exception>
[SecurityPermissionAttribute(SecurityAction.Demand, SerializationFormatter = true)]
public override void GetObjectData(SerializationInfo info, StreamingContext context)

/// <summary>
///初始化SyncDictionary对象实例
/// </summary>
/// <param name="info"><see cref="System.Runtime.Serialization.SerializationInfo"></see>对象包含序列化<see cref="System.Collections.Generic.Dictionary{TKey, TValue}"></see>的必要信息。</param>
/// <param name="context">A<see cref="System.Runtime.Serialization.StreamingContext"></see>含有与序列化流<see cref="System.Collections.Generic.Dictionary{TKey, TValue}"></see>的源和目标的结构。</param>
internal SyncDictionary(SerializationInfo info, StreamingContext context): base(info, context)

/// <summary>
///把ICollection的元素复制到一个KeyValuePair类型的数组，在指定的阵列索引开始。
/// </summary>
/// <param name="array">一维数组类型KeyValuePair是从ICollection复制KeyValuePair元素的目标。该数组必须具有从零开始的索引。</param>
/// <param name="index">array中的从零开始的索引，位于复制开始</param>
public new void CopyTo(KeyValuePair<TKey, TValue>[] array, int index)

/// <summary>
///实现<see cref="System.Runtime.Serialization.ISerializable"></see>接口并抛出反序列化事件，当反序列化完成的时候。
/// </summary>
/// <param name="sender">反序列化事件的源对象</param>
/// <exception cref="T:System.Runtime.Serialization.SerializationException">在当前字典中关联的该对象为无效对象.</exception>
public override void OnDeserialization(object sender)

/// <summary>
///确定指定的键是否包含关键。
/// </summary>
/// <param name="key">键</param>
/// <returns>
///如果包含指定的键返回True，否则false。
/// </returns>
public new bool ContainsKey(TKey key)

/// <summary>
///判断<see cref="System.Collections.Generic.Dictionary{TKey, TValue}"></see>是否包含指定的值
/// </summary>
/// <param name="value">在字典中待查找的值，如果值是引用类型则可以为null。</param>
/// <returns>
///如果<see cref="System.Collections.Generic.Dictionary{TKey, TValue}"></see>包含指定值的元素返回true，否则返回false.
/// </returns>
public new bool ContainsValue(TValue value)

SyncDictionary<string, string> syncDict = new SyncDictionary<string, string>();
syncDict.Add("A", "testA");
syncDict.Add("C", "testC");
syncDict.Add("B", "TestB");

//通过键访问
StringBuilder sb = new StringBuilder();
foreach (string key in syncDict.Keys)
{
sb.AppendFormat("{0}:{1}\r\n", key, syncDict[key]);
}
sb.AppendLine();
MessageUtil.ShowTips(sb.ToString());  

SyncDictionary<string, string> syncDict = new SyncDictionary<string, string>();
private void btnSyncTest_Click(object sender, EventArgs e)
{
for (int i = 0; i < 5; i++)
{
Thread thread = new Thread(new ThreadStart(AddSyncDict));
thread.Start();
thread.Join();//等待线程完成才返回主线程
    }

StringBuilder sb = new StringBuilder();
foreach (string key in syncDict.Keys)
{
sb.AppendFormat("Key:{0}   Value:{1} \r\n", key, syncDict[key]);
}
MessageUtil.ShowTips(sb.ToString());
}

private void AddSyncDict()
{
string key = new Random().Next().ToString();
if (!syncDict.ContainsKey(key))
{
syncDict.Add(key, DateTime.Now.ToString());
}
Thread.Sleep(100);
}  

SyncOrderedDictionary<string, string> syncDict = new SyncOrderedDictionary<string, string>();
syncDict.Add("A", "testA");
syncDict.Add("C", "testC");
syncDict.Add("B", "TestB");

//通过键访问
StringBuilder sb = new StringBuilder();
foreach (string key in syncDict.Keys)
{
sb.AppendFormat("{0}:{1}\r\n", key, syncDict[key]);
}
sb.AppendLine();

//通过索引访问
for (int i = 0; i < syncDict.Keys.Count; i++)
{
sb.AppendFormat("{0}:{1}\r\n", i, syncDict[i]);
}
MessageUtil.ShowTips(sb.ToString());  

/// <summary>
///初始化一个同步列表对象实例
/// </summary>
public SyncList()

/// <summary>
///初始化一个同步列表对象实例
/// </summary>
/// <param name="list">The list.</param>
public SyncList(CList<T> list)

/// <summary>
///获取一个值，判断<see cref="System.Collections.ICollection"></see>是否为同步的（线程安全）.
/// </summary>
/// <value>如果为同步（线程安全）的，返回true,否则false. 默认为false</value>
/// <returns>如果为同步（线程安全）的，返回true,否则false</returns>
public override bool IsSynchronized

/// <summary>添加一个对象到<see cref="System.Collections.Generic.List<T>"></see>末尾.</summary>
/// <param name="item">待添加的对象. 值可以为空引用类型。</param>
public new void Add(T item)

/// <summary>添加一个集合到<see cref="System.Collections.Generic.List<T>"></see>末尾</summary>
/// <param name="collection">其集合元素待添加到<see cref="System.Collections.Generic.List<T>"></see>末尾的集合.
///集合本身不能为空，但如果类型TKey是一个引用类型，则它包含的元素可以为空</param>
/// <exception cref="System.ArgumentNullException">集合为空</exception>
public new void AddRange(IEnumerable<T> collection)

/// <summary>
///为当前集合返回一个只读的<see cref="System.Collections.Generic.IList<T>"></see>包装类。
/// </summary>
public new ReadOnlyCollection<T> AsReadOnly()

/// <summary>
///从<see cref="System.Collections.Generic.List<T>"></see>集合中移除所有对象。
/// </summary>
public new void Clear()

/// <summary>判定指定的元素是否在<see cref="System.Collections.Generic.List<T>"></see>中.</summary>
/// <returns>如果元素在<see cref="System.Collections.Generic.List<T>"></see>中存在返回true，否则返回false.</returns>
/// <param name="item">待查找的元素，如果值为引用类型则可以为null</param>
public new bool Contains(T item)

/// <summary>
///转换当前<see cref="System.Collections.Generic.List<T>"></see>的元素到另外的类型，并返回包含转换后的元素列表。
/// </summary>
/// <returns>一个<see cref="System.Collections.Generic.List<T>"></see>集合，包含当前集合转换后的元素。</returns>
/// <param name="converter">每个元素从一种类型到另一种类型的转换委托</param>
/// <exception cref="System.ArgumentNullException">converter 为 null.</exception>
public new CList<TOutput> ConvertAll<TOutput>(Converter<T, TOutput> converter)

/// <summary>复制整个<see cref="System.Collections.Generic.List<T>"></see>到一个一维数组中</summary>
/// <param name="array">一维数组，从列表中复制元素的目标对象。该数组必须具有从零开始的索引。</param>
/// <exception cref="System.ArgumentException">源列表中元素的数量大于目标数组能容纳的数量</exception>
/// <exception cref="System.ArgumentNullException">array 为 null.</exception>
public new void CopyTo(T[] array)

/// <summary>复制整个<see cref="System.Collections.Generic.List<T>"></see>到一个一维数组中</summary>
/// <param name="array">一维数组，从列表中复制元素的目标对象。该数组必须具有从零开始的索引。</param>
/// <param name="arrayIndex">array中的从零开始的索引，位于复制开始。</param>
/// <exception cref="System.ArgumentException">arrayIndex 大于或等于array数组长度；或源列表的元素数量大于目标array数组从arrayIndex到结束的可用空间</exception>
/// <exception cref="System.ArgumentOutOfRangeException">arrayIndex 小于等于 0.</exception>
/// <exception cref="System.ArgumentNullException">array 为 null.</exception>
public new void CopyTo(T[] array, int arrayIndex)

/// <summary>
///从列表中复制一个范围内的元素到一个相容的一维数组中。以指定的目标索引开始。
/// </summary>
/// <param name="index">在从零开始的索引，位于复制开始的源。</param>
/// <param name="array">一维数组，从列表中复制元素的目标对象。该数组必须具有从零开始的索引。</param>
/// <param name="arrayIndex">array中的从零开始的索引，位于复制开始。</param>
/// <param name="count">待复制的元素数量.</param>
/// <exception cref="System.ArgumentNullException">array 为 null.</exception>
/// <exception cref="System.ArgumentOutOfRangeException">index 小于 0；或者arrayIndex 小于0；或者count 小于 0.</exception>
/// <exception cref="System.ArgumentException">index 大于或等于源列表的数量。或者arrayIndex 大于或等于数组array的长度。或者从index到源列表结束的元素数量大于从 arrayIndex 到数组array结束的可用空间。</exception>
public new void CopyTo(int index, T[] array, int arrayIndex, int count)

/// <summary>
///判定<see cref="System.Collections.Generic.List<T>"></see>是否包含符合定义在指定predicate的条件中包含有元素。</summary>
/// <returns>如果列表中包含指定条件的元素，返回true，否则为false。</returns>
/// <param name="match">定义元素的条件来搜索对象的委托</param>
/// <exception cref="System.ArgumentNullException">match 为 null.</exception>
public new bool Exists(Predicate<T> match)

/// <summary>根据定义条件查询一个元素，并返回第一个在整个列表中出现的元素.</summary>
/// <returns>根据查询条件，第一个在整个列表中出现的元素，如果没有找到，返回Tkey类型的默认值。</returns>
/// <param name="match">定义元素的条件来搜索的委托</param>
/// <exception cref="System.ArgumentNullException">match 为 null.</exception>
public new T Find(Predicate<T> match)

/// <summary>获取指定Predicate定义的条件相匹配的所有元素。</summary>
/// <returns>如果遭到元素，返回指定Predicate定义的条件相匹配的所有元素列表，否则返回一个空列表。</see>.</returns>
/// <param name="match">定义元素的条件来搜索的委托</param>
/// <exception cref="System.ArgumentNullException">match 为 null.</exception>
public new CList<T> FindAll(Predicate<T> match)
。。。。。。。。。。。。。。。。。

SyncList<string> syncList = new SyncList<string>();
private void btnSyncTest_Click(object sender, EventArgs e)
{
for (int i = 0; i < 5; i++)
{
Thread thread = new Thread(new ThreadStart(AddSyncList));
thread.Start();
thread.Join();//等待线程完成才返回主线程
    }

StringBuilder sb = new StringBuilder();
foreach (string item in syncList)
{
sb.AppendFormat("item:{0} \r\n", item);
}
MessageUtil.ShowTips(sb.ToString());
}

private void AddSyncList()
{
string key = new Random().Next().ToString();
syncList.Add(key);
Thread.Sleep(100);
}  

/// <summary>
///队列中目前存在个数
/// </summary>
public int Count

/// <summary>
///队列的最大容量
/// </summary>
public int MaxCount

/// <summary>
///重新设置队列的最大容量
/// </summary>
/// <param name="MaxCount">大于1的整数</param>
public void ResetMaxCount(int MaxCount)

/// <summary>
///元素进队， 将指定的对象值添加到队列的尾部
/// </summary>
/// <param name="obj">T 型的参数</param>
public void Append(T obj)

/// <summary>
///元素出队，即移除队列中开始的元素，按先进先出（FIFO）的规则，从前向后移除元素。
/// </summary>
/// <returns></returns>
public T Pop()  

/// <summary>
///组包后数据的队列（先进先出）
/// </summary>
protected Fifo<PreData> _preDataFifo = new Fifo<PreData>(50000);

/// <summary>
///接收处理数据
/// </summary>
/// <param name="data">包体</param>
public void AppendPreData(PreData data)
{
this._preDataFifo.Append(data);
}

/// <summary>
///数据处理
/// </summary>
protected virtual void PreDataHandle()
{
try
{
while (true)
{
PreData data = _preDataFifo.Pop();
if (data != null)
{
PreDataHandle(data);
}
}
}
catch(Exception ex)
{
string message = string.Format("[{0}.PreDataHandle]  desc:接收器处理异常->{1}", this._Name, ex.ToString());
Log.WriteError(message, ex.ToString(), true);
}
}

/// <summary>
///对每一个包体的数据进行处理
/// </summary>
/// <param name="data">包体</param>
public virtual void PreDataHandle(PreData data)
{
}         

/// <summary>
///冒泡排序法
/// </summary>
/// <param name="list">待排序数组</param>
public static void BubbleSort(int[] list)

/// <summary>
///插入排序法
/// </summary>
/// <param name="list">待排序数组</param>
public static void InsertionSort(int[] list)

/// <summary>
///选择排序法
/// </summary>
/// <param name="list">待排序数组</param>
public static void SelectionSort(int[] list)

/// <summary>
///希尔排序法
/// </summary>
/// <param name="list">待排序数组</param>
public static void ShellSort(int[] list)

/// <summary>
///快速排序法
/// </summary>
/// <param name="list">待排序数组</param>
/// <param name="low">低位</param>
/// <param name="high">高位</param>
public static void QuickSort(int[] list, int low, int high)  

private void btnSort_Click(object sender, EventArgs e)
{
//冒泡排序法
    int[] list = new int[10] { 0, 1, 2, 3, 4, 9, 8, 7, 6, 5 };
SortHelper.BubbleSort(list);
StringBuilder sb = new StringBuilder();
foreach (int i in list)
{
sb.AppendFormat("{0},", i);
}
MessageUtil.ShowTips(sb.ToString());

//插入排序法
    list = new int[10] { 0, 1, 2, 3, 4, 9, 8, 7, 6, 5 };
SortHelper.InsertionSort(list);
sb = new StringBuilder();
foreach (int i in list)
{
sb.AppendFormat("{0},", i);
}
MessageUtil.ShowTips(sb.ToString());
}