俗話說，一個好漢十個幫，眾人拾柴火焰高等都說明一個道理，有更多的資源，更豐富的積累，都是助你走向成功，走向頂峰的推動力。
本篇的公用類庫的介紹主題是程序開發中多線程操作環境中，常用到的線程安全的各類同步集合、字典等對象，這些輔助類通過封裝及繼承關系，獲得更加豐富完善的集合類，並且增加了線程鎖，實現多線程訪問的集合類。本篇隨筆介紹包含有有序字典集合、同步字典集合、有序同步字典集合、同步列表、同步先進先出隊列等對象。
本篇繼續繼續整理優化已有的共用類庫，並繼續發表隨筆介紹公用類庫的接口方法以及詳細使用操作，力求給自己繼續優化，積攢更豐富的公用類庫資源，加深了解的同時，也給大家展現公用類庫好的方面。
厚積薄發，豐富的公用類庫積累，助你高效進行系統開發（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>是否包含符合定義在指定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);
}
輸出結果如下所示。
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> _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)
{
}
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());
}
其他的接口排序差不多也是如此調用和結果的，只是在排序效率上有所差異。