0
回答
厚积薄发,丰富的公用类库积累,助你高效进行系统开发(10)---各种线程同步的集合类
利用AWS快速构建适用于生产的无服务器应用程序,免费试用12个月>>>   

俗话说,一个好汉十个帮,众人拾柴火焰高等都说明一个道理,有更多的资源,更丰富的积累,都是助你走向成功,走向顶峰的推动力。

本篇的公用类库的介绍主题是程序开发中多线程操作环境中,常用到的线程安全的各类同步集合、字典等对象,这些辅助类通过封装及继承关系,获得更加丰富完善的集合类,并且增加了线程锁,实现多线程访问的集合类。本篇随笔介绍包含有有序字典集合、同步字典集合、有序同步字典集合、同步列表、同步先进先出队列等对象。

本篇继续继续整理优化已有的共用类库,并继续发表随笔介绍公用类库的接口方法以及详细使用操作,力求给自己继续优化,积攒更丰富的公用类库资源,加深了解的同时,也给大家展现公用类库好的方面。

厚积薄发,丰富的公用类库积累,助你高效进行系统开发(9)----各种常用辅助类
厚积薄发,丰富的公用类库积累,助你高效进行系统开发(8)----非对称加密、BASE64加密、MD5等常用加密处理
厚积薄发,丰富的公用类库积累,助你高效进行系统开发(7)-----声音播放、硬件信息、键盘模拟及钩子、鼠标模拟及钩子等设备相关 
厚积薄发,丰富的公用类库积累,助你高效进行系统开发(6)----全屏截图、图标获取、图片打印、页面预览截屏、图片复杂操作等
厚积薄发,丰富的公用类库积累,助你高效进行系统开发(5)----热键、多线程、窗体动画冻结等窗体操作
厚积薄发,丰富的公用类库积累,助你高效进行系统开发(4)----CSV、Excel、INI文件、独立存储等文件相关
厚积薄发,丰富的公用类库积累,助你高效进行系统开发(3)----数据库相关操作
厚积薄发,丰富的公用类库积累,助你高效进行系统开发(2)----常用操作
厚积薄发,丰富的公用类库积累,助你高效进行系统开发(1)----开篇总结

1、有序的字典集合 OrderedDictionary。  

实现效果

1) 本辅助类主要是用来方便实现有序的字典集合操作。 一个有序的字典是一个集合类,它里面的项目可以通过其索引或他们的键进行操作。。
2) 有序集合对象,特点是查找非常高效率,并且提供了强类型的数据操作,不过由于其需要额外在列表中存储数据,因此尽量减少插入或者删除集合对象。
3) 有序的字典集合,虽然存在一些缺点,但是提供了一个非常灵活和用户友好数据结构,允许通过键值或索引进行访问。

实现代码

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

 

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

 

3)  辅助类OrderedDictionary和.NET框架内置SortedDictionary不同,他虽然都支持泛型类型,不过键和索引方式访问,后者只是对键进行排序的字典类,并未提供以索引方式进行取值的。

// 框架内置的排序字典
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());

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

 

2、同步的字典集合 SyncDictionary。  

实现效果

1) 现同步的字典集合操作。 一个同步的字典提供一个线程安全的字典集合。
2) 同步字典对象,提供了多线程之间线程安全的访问机制,使你不必担心发送多线程之间的添加、移除、访问等的冲突,放心使用。
3) SyncDictionary类继承了CDictionary类,CDictionary继承了框架的Dictionary类,CDictionary并实现了一些克隆及序列化的接口。SyncDictionary类具有Dictionary类的一切特点,另外他还具备线程安全的特点。

 

实现代码

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)



2)本辅助类主要是用来方便实辅助类SyncDictionary的使用例子代码如下所示,由于SyncDictionary线程安全,非常适合在多线程的环境下进行操作,如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());

输出结果如下所示,我们看到,他们虽然可以通过键和索引进行访问,但是他们的顺序不会发生变化。

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

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

 

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

实现效果

1)本辅助类主要是用来方便实现同步、有序的字典集合操作。 一个同步的字典提供一个线程安全的字典集合;一个有序的字典是一个集合类,它里面的项目可以通过其索引或他们的键进行操作。。
2) 同步字典对象,提供了多线程之间线程安全的访问机制,使你不必担心发送多线程之间的添加、移除、访问等的冲突,放心使用。
3) 有序集合对象,特点是查找非常高效率,并且提供了强类型的数据操作,不过由于其需要额外在列表中存储数据,因此尽量减少插入或者删除集合对象。
4) 有序的字典集合,虽然存在一些缺点,但是提供了一个非常灵活和用户友好数据结构,允许通过键值或索引进行访问。
5) SyncOrderedDictionary类继承了OrderedDictionary类,具有OrderedDictionary类的一切特点,另外他还具备线程安全的特点。

 

实现代码

1)辅助类提供的方法接口如下所示: 

 接口综合了以上两种(同步、有序)字典类的特点,接口代码不在粘贴出来。

 

2)辅助类SyncOrderedDictionary的使用例子代码如下所示,由于SyncOrderedDictionary在检索的时候效率很高,而且可以通过索引和键进行定位,提供了较好的操作性和方便性。另外由于线程安全,非常适合在多线程的环境下进行操作,如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());

输出结果如下所示,我们看到,他们虽然可以通过键和索引进行访问,但是他们的顺序不会发生变化。

 

4、同步的列表集合 SyncList。  

实现效果

1) 本辅助类主要是用来方便实现同步列表集合操作。 一个同步的列表集合提供一个线程安全的列表集合;
2)同步字典对象,提供了多线程之间线程安全的访问机制,使你不必担心发送多线程之间的添加、移除、访问等的冲突,放心使用。

 

实现代码

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> 是否包含符合定义在指定dicate的条件中包含有元素。 </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);
}

输出结果如下所示。


5、线程安全的先进先出队列辅助类 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> _DataFifo = new Fifo<PreData>( 50000);

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

/// <summary>
/// 数据处理
/// </summary>
protected virtual void PreDataHandle()
{
try
{
while ( true)
{
PreData data = _DataFifo.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)
{
}


6、各种常用数组排序操作辅助类 SortHelper。  

实现效果

 1) 本辅助类主要是用来方便实现各种常用数组排序操作,包括冒泡排序法、插入排序法、选择排序法、希尔排序法、快速排序法。 

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

其他的接口排序差不多也是如此调用和结果的,只是在排序效率上有所差异。


原文链接:http://www.cnblogs.com/wuhuacong/archive/2012/03/25/2416764.html
<无标签>
举报
长平狐
发帖于5年前 0回/71阅
顶部