积累更丰盛的公用类库财富,积攒更增进的公用类库财富

俗话说,三个无名大侠拾3个帮,众擎易举等都证实三个道理,有更多的能源,更增进的积聚,都是助你走向成功,走向极端的带重力。

俗话说,二个无名英豪十一个帮,众擎易举等都说澳优个道理,有更多的能源,更足够的累积,都是助你走向成功,走向极端的牵重力。

本篇的公用类库的介绍大旨是先后开发中八线程操作环境中,常用到的线程安全的各项同步集合、字典等对象,那一个帮忙类通过包装及后续关系,获得进一步丰硕周详的集合类,并且扩张了线程锁,达成多线程访问的集合类。本篇小说介绍包蕴有静止字典集合、同步字典集合、有序同步字典集合、同步列表、同步先进先出队列等对象。

本篇的公用类库的介绍大旨是程序支付中八线程操作环境中,常用到的线程安全的各个同步集合、字典等目的,这个帮助类通过包装及后续关系,获得进一步充分全面包车型地铁集合类,并且扩充了线程锁,完结多线程访问的集合类。本篇随笔介绍包含有静止字典集合、同步字典集合、有序同步字典集合、同步列表、同步先进先出队列等指标。

本篇继续持续整治优化已有的共用类库,并继续发布小说介绍公用类库的接口方法以及详细使用操作,力求给协调继续优化,积攒更丰裕的公用类库能源,加深精晓的还要,也给我们突显公用类库好的方面。

本篇继续持续整治优化已有的共用类库,并连任公布随笔介绍公用类库的接口方法以及详细使用操作,力求给本身连续优化,积攒更增加的公用类库财富,加深掌握的还要,也给大家展现公用类库好的地点。
**1、有序的字典集合 OrderedDictionary。 **
福寿无疆效益

蓄势待发,丰硕的公用类库积累,助你急忙开始展览系统开发(9)—-各个常用支持类
蓄势待发,丰硕的公用类库积累,助你快捷开始展览系统开发(8)—-非对称加密、BASE64加密、MD5等常用加密处理 蓄势待发,丰富的公用类库积累,助你神速开始展览系统开发(7)—–声音播放、硬件音讯、键盘模拟及钩子、鼠标模拟及钩子等设备相关 
蓄势待发,足够的公用类库积累,助你火速开始展览系统开发(6)—-全屏截图、图标获取、图片打字与印刷、页面预览截屏、图片复杂操作等 蓄势待发,丰硕的公用类库积累,助你火速开始展览系统开发(5)—-热键、多线程、窗体动画冻结等窗体操作 蓄势待发,充分的公用类库积累,助你火速开展系统开发(4)—-CSV、Excel、INI文件、独立存款和储蓄等文件有关 蓄势待发,足够的公用类库积累,助你快捷开始展览系统开发(3)—-数据库相关操作 蓄势待发,充足的公用类库积累,助你飞快开展系统开发(2)—-常用操作 蓄势待发,丰富的公用类库积累,助你火速开始展览系统开发(1)—-开篇总括

  1. 本协理类首假如用来方便实现稳步的字典集合操作。
    3个静止的字典是叁个集合类,它在那之中的品类方可经过其索引或他们的键举办操作。。 2)
    有序聚集对象,特点是寻觅相当高成效,并且提供了强类型的数额操作,不过由于其须求非常在列表中贮存数据,由此尽量减弱插入只怕去除集合对象。 3)
    有序的字典集合,尽管存在部分败笔,不过提供了2个分外灵活和用户自个儿数据结构,允许通过键值或索引举行访问。
    落到实处代码
    1)帮助类提供的办法接口如下所示:

壹 、有序的字典集合 OrderedDictionary。  

年年有余效益

/// <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()   

1) 本帮忙类首假若用来便宜完毕稳步的字典集合操作。
两个照猫画虎的字典是八个集合类,它里面包车型地铁系列能够经过其索引或他们的键进行操作。。
2)
有序聚集对象,特点是寻找卓殊高效用,并且提供了强类型的多少操作,然而鉴于其急需额外在列表中贮存数据,因而尽量减弱插入只怕去除集合对象。
3)
有序的字典集合,就算存在一些缺点,不过提供了1个格外灵活和用户本身数据结构,允许通过键值或索引举行走访。

2)扶助类OrderedDictionary的选取例子代码如下所示,由于OrderedDictionary在探寻的时候成效很高,而且能够通过索引和键进行固化,提供了较好的可操作性和方便性。
输出结果如下所示,咱们看看,他们即便能够由此键和目录实行访问,不过他们的逐一不会发生变化。

兑现代码

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()); 

1)帮衬类提供的法子接口如下所示: 

图片 1

/// <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()   
  1. 扶植类OrderedDictionary和.NET框架内置SortedDictionary分歧,他固然都援救泛型类型,可是键和目录情势访问,后者只是对键进行排序的字典类,并未提供以索引格局进行取值的。

 

2)协助类OrderedDictionary的采用例子代码如下所示,由于OrderedDictionary在寻觅的时候效用很高,而且能够通过索引和键举行固化,提供了较好的可操作性和方便性。 输出结果如下所示,大家看看,他们尽管能够由此键和目录进行访问,可是他们的逐一不会产生变化。

//框架内置的排序字典    
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());  
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例子的输出结果如下所示,从中我们得以见见,遍历键的时候,它们已经因而了假名从大到小进行排序了。

图片 2

图片 3

 

**贰 、同步的字典集合 SyncDictionary。 **
兑现效益

3)
 援助类OrderedDictionary和.NET框架内置SortedDictionary分歧,他虽说都补助泛型类型,然则键和目录情势访问,后者只是对键进行排序的字典类,并未提供以索引情势实行取值的。

  1. 现同步的字典集合操作。 叁个一块的字典提供二个线程安全的字典集合。 2)
    同步字典对象,提供了三十二线程之间线程安全的走访机制,使你不用担心发送十六线程之间的充分、移除、访问等的冲突,放心使用。 3)
    SyncDictionary类继承了CDictionary类,CDictionary继承了框架的Dictionary类,CDictionary并贯彻了一部分仿制及系列化的接口。SyncDictionary类具有Dictionary类的凡事特点,此外他还装有线程安全的风味。
//框架内置的排序字典    
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());  

实现代码
1)援救类提供的方法接口如下所示:

而SortedDictionary例子的输出结果如下所示,从中我们得以见到,遍历键的时候,它们已经经过了字母从大到小实行排序了。

/// <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)  

图片 4

2)本帮忙类首如果用来便宜实帮衬类SyncDictionary的行使例子代码如下所示,由于SyncDictionary线程安全,13分适合在八线程的环境下进行操作,如Socket服务器处理、后台线程数据处理等条件下。

 

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());  

2、同步的字典集合 SyncDictionary。  

输出结果如下所示,大家看到,他们尽管能够透过键和目录实行访问,但是她们的相继不会产生变化。

金镶玉裹福禄双全效益

图片 5

1) 现同步的字典集合操作。 三个共同的字典提供1个线程安全的字典集合。
2)
同步字典对象,提供了八线程之间线程安全的造访机制,使您不要顾虑发送二十四线程之间的丰裕、移除、访问等的争持,放心使用。
3)
SyncDictionary类继承了CDictionary类,CDictionary继承了框架的Dictionary类,CDictionary并贯彻了有个别仿制及种类化的接口。SyncDictionary类具有Dictionary类的整套特点,其余他还存有线程安全的特征。

  1. 别的它的线程安全,使得其多线程之间的操作也是十分安全、高效的。

 

兑现代码

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

1)帮忙类提供的方法接口如下所示: 

二十十二线程之间操作的运维效果如下所示

/// <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)  

图片 6

2)本协理类主尽管用来便于实支持类SyncDictionary的利用例子代码如下所示,由于SyncDictionary线程安全,卓殊适合在八线程的条件下展开操作,如Socket服务器处理、后台线程数据处理等条件下。

**三 、同步、有序的字典集合 SyncOrderedDictionary。 **
福寿齐天效益
1)本援助类重要是用来便于达成联机、有序的字典集合操作。
3个手拉手的字典提供1个线程安全的字典集合;七个稳步的字典是3个集合类,它里面的品类可以通过其索引或他们的键举行操作。。
2)
同步字典对象,提供了四线程之间线程安全的访问机制,使您不要顾虑发送多线程之间的增加、移除、访问等的争持,放心使用。
3)
有序聚集对象,特点是寻找相当高功效,并且提供了强类型的多寡操作,然则是因为其索要额外在列表中储存数据,由此尽量减少插入恐怕去除集合对象。
4)
有序的字典集合,尽管存在有的瑕疵,可是提供了2个相当灵活和用户本人数据结构,允许通过键值或索引举行访问。
5)
SyncOrderedDictionary类继承了OrderedDictionary类,具有OrderedDictionary类的全体特点,此外她还拥有线程安全的性状。

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());  

金镶玉裹福禄双全代码
1)帮衬类提供的情势接口如下所示:
接口综合了以上二种(同步、有序)字典类的性状,接口代码不在粘贴出来。

出口结果如下所示,大家看到,他们纵然能够透过键和目录进行走访,可是她们的相继不会爆发变化。

2)帮助类SyncOrderedDictionary的应用例子代码如下所示,由于SyncOrderedDictionary在寻找的时候功效很高,而且可以因而索引和键实行一定,提供了较好的可操作性和方便性。其它由于线程安全,卓殊适合在八线程的条件下进展操作,如Socket服务器处理、后台线程数据处理等环境下。

图片 7

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());  

3) 别的它的线程安全,使得其二十八线程之间的操作也是相当安全、高效的。

输出结果如下所示,大家看到,他们即使能够透过键和目录举办访问,可是她们的相继不会发生变化。

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

图片 8

八线程之间操作的运作效果如下所示

**④ 、同步的列表集合 SyncList。 **
完结效益
1) 本帮助类重若是用来方便达成共同列表集合操作。
3个手拉手的列表集合提供2个线程安全的列表集合;
2)同步字典对象,提供了十六线程之间线程安全的造访机制,使你不用担心发送三十二线程之间的丰裕、移除、访问等的争辨,放心使用。

图片 9

金镶玉裹福禄双全代码
1)帮助类提供的主意接口如下所示,该类继承二个自定义的CList,CList完毕了克隆等局部接口,SyncList的函数接口定义如下:

 

/// <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)    
。。。。。。。。。。。。。。。。。

三 、同步、有序的字典集合 SyncOrderedDictionary。  

2)扶助类SyncList的行使例子代码如下所示,由于线程安全,10分适合在多线程的条件下展开操作,如Socket服务器处理、后台线程数据处理等环境下。

贯彻效益

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

1)本援救类首假诺用来便宜实现同步、有序的字典集合操作。
2个联合举行的字典提供二个线程安全的字典集合;三个稳步的字典是三个集合类,它当中的品类方可因此其索引或他们的键进行操作。。
2)
同步字典对象,提供了多线程之间线程安全的拜访机制,使你不用担心发送多线程之间的丰富、移除、访问等的抵触,放心使用。
3)
有序聚集对象,特点是寻觅10分高效用,并且提供了强类型的数目操作,然则出于其急需额外在列表中蕴藏数据,由此尽量减少插入或许去除集合对象。
4)
有序的字典集合,固然存在部分欠缺,不过提供了二个万分灵活和用户自身数据结构,允许通过键值或索引举办走访。
5)
SyncOrderedDictionary类继承了OrderedDictionary类,具有OrderedDictionary类的整个特点,此外她还持有线程安全的特性。

输出结果如下所示。

 

图片 10

达成代码


1)支持类提供的不二法门接口如下所示: 

**伍 、线程安全的先进先出队列扶助类 Fifo。 **
贯彻效益
1) 本帮助类首尽管用来便宜完结线程安全的先进先出队列操作。
2)线程安全的先进先出队列,提供了八线程之间线程安全的拜会机制,使你不用担心发送多线程之间的进队、出队等的争辩,放心使用。
3)Fifo类组合了先进先出的Queue类,提供了线程安全的操作,称为队列或环形缓冲区,那是一种采纳先进先出结构(FIFO)的数据结构。现实生活中这种布局选取得不行广阔。比如一些公司的货仓管理类别,要求将先生产的货色先出货,后生产的货品后出货。别的一种现象正是Socket数据包处理的时候,大家一般是把她放到Fifo队列里面,达成先进先出的客体处理。

 接口综合了上述二种(同步、有序)字典类的性情,接口代码不在粘贴出来。

兑现代码
1)帮忙类提供的措施接口如下所示:

 

/// <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()  

2)支持类SyncOrderedDictionary的使用例子代码如下所示,由于SyncOrderedDictionary在寻觅的时候功能很高,而且能够透过索引和键举行固化,提供了较好的操作性和方便性。其它由于线程安全,万分适合在十二线程的条件下进展操作,如Socket服务器处理、后台线程数据处理等条件下。

2)扶助类Fifo的运用例子代码如下所示,由于Fifo线程安全,非凡适合在八线程的环境下展开操作,如Socket服务器处理、后台线程数据处理等条件下。

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>
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)    
{     
}    

出口结果如下所示,大家看到,他们就算能够透过键和目录举办走访,可是她们的逐条不会发生变化。

**⑥ 、各样常用数组排序操作扶助类 SortHelper****。 **
福寿年高效益
1)
本扶助类首假若用来便于完毕种种常用数组排序操作,包蕴冒泡排序法、插入排序法、选拔排序法、希尔排序法、急忙排序法。
2) 本协助类提供部分常用的排序操作,也足以用作读书排序的基础教程。

图片 11

兑现代码
1)扶助类提供的法子接口如下所示:

 

/// <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)  

④ 、同步的列表集合 SyncList。  

2)扶助类SortHelper的应用例子代码如下所示。

兑现效益

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());    
}  

1) 本协理类首要是用来方便完成联机列表集合操作。
3个联机的列表集合提供一个线程安全的列表集合;
2)同步字典对象,提供了八线程之间线程安全的拜访机制,使您不要担心发送二十二十四线程之间的增进、移除、访问等的争执,放心使用。

图片 12

 

别的的接口排序差不离也是那般调用和结果的,只是在排序效用上有着差异。

兑现代码

1)支持类提供的形式接口如下所示,该类继承1个自定义的CList,CList完毕了克隆等部分接口,SyncList的函数接口定义如下: 

/// <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)    
。。。。。。。。。。。。。。。。。

  

2)协助类SyncList的应用例子代码如下所示,由于线程安全,卓殊适合在二十二十四线程的环境下开始展览操作,如Socket服务器处理、后台线程数据处理等环境下。

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

出口结果如下所示。

图片 13

伍 、线程安全的先进先出队列补助类 Fifo。  

兑现效益

1) 本扶助类首尽管用来便宜完结线程安全的先进先出队列操作。
2)线程安全的先进先出队列,提供了八线程之间线程安全的走访机制,使你不用担心发送三十二线程之间的进队、出队等的争执,放心使用。
3)Fifo类组合了先进先出的Queue类,提供了线程安全的操作,称为队列或环形缓冲区,那是一种选择先进先出结构(FIFO)的数据结构。现实生活中那种结构选用得十二分广泛。比如一些商家的货仓管理体系,须求将先生产的商品先出货,后生育的货色后出货。此外一种现象便是Socket数据包处理的时候,大家一般是把她放到Fifo队列里面,完结先进先出的创制处理。

 

兑现代码

1)匡助类提供的主意接口如下所示: 

/// <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()  

 

2)支持类Fifo的选用例子代码如下所示,由于Fifo线程安全,万分适合在二十八线程的环境下进展操作,如Socket服务器处理、后台线程数据处理等环境下。 

/// <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)    
{     
}         

六 、种种常用数组排序操作支持类 SortHelper。  

兑现效益

 1) 本帮忙类首假如用来便于完成各个常用数组排序操作,包涵冒泡排序法、插入排序法、选取排序法、Hill排序法、急速排序法。 

2) 本扶助类提供部分常用的排序操作,也能够看成读书排序的基础教程。

 

兑现代码

1)协理类提供的法子接口如下所示: 

/// <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)  

2)扶助类SortHelper的施用例子代码如下所示。

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());    
}  

图片 14

任何的接口排序差不离也是那样调用和结果的,只是在排序成效上富有差距。

相关文章