由于MS没有提供List的线程安全集合.自己动手写了一个,不过性能…不高..对于性能要求不高的情况下可以使用.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace System.Collections.Concurrent
{
/// <summary>
/// 线程安全的List集合
/// </summary>
/// <typeparam name="T">类型</typeparam>
public class ConcurrentList<T> : IList<T>
{
/// <summary>
///创建一个纯种安全的List集合对像
/// </summary>
public ConcurrentList()
{
list = new List<T>();
}
/// <summary>
/// 内部的索引器访问对像
/// </summary>
protected List<T> list;
/// <summary>
/// 锁对像
/// </summary>
protected int lockInt;
#region IList
/// <summary>
/// 搜索指定的对象，并返回整个 System.Collections.Generic.List<T> 中第一个匹配项的从零开始的索引。
/// </summary>
/// <param name="item">对像</param>
/// <returns></returns>
public int IndexOf(T item)
{
bool gotLock = false;
try
{
splock.Enter(ref gotLock);
return list.IndexOf(item);
}
finally
{
if (gotLock)
{
splock.Exit();
}
}
}
/// <summary>
/// 将元素插入 System.Collections.Generic.List<T> 的指定索引处。
/// </summary>
/// <param name="index">指定索引</param>
/// <param name="item">元素</param>
public void Insert(int index, T item)
{
bool gotLock = false;
try
{
splock.Enter(ref gotLock);
list.Insert(index, item);
}
finally
{
if (gotLock)
{
splock.Exit();
}
}
}
/// <summary>
/// 移除 System.Collections.Generic.List<T> 的指定索引处的元素。
/// </summary>
/// <param name="index">指定索引</param>
public void RemoveAt(int index)
{
bool gotLock = false;
try
{
splock.Enter(ref gotLock);
list.RemoveAt(index);
}
finally
{
if (gotLock)
{
splock.Exit();
}
}
}
public T this[int index]
{
get
{
System.Threading.Interlocked.Increment(ref lockInt);
try
{
return list[index];
}
finally
{
System.Threading.Interlocked.Decrement(ref lockInt);
}
}
set
{
System.Threading.Interlocked.Increment(ref lockInt);
try
{
list[index] = value;
}
finally
{
System.Threading.Interlocked.Decrement(ref lockInt);
}
}
}
public void Add(T item)
{
bool gotLock = false;
try
{
splock.Enter(ref gotLock);
list.Add(item);
}
finally
{
if (gotLock)
{
splock.Exit();
}
}
}
public void Clear()
{
bool gotLock = false;
try
{
splock.Enter(ref gotLock);
list.Clear();
}
finally
{
if (gotLock)
{
splock.Exit();
}
}
}
public bool Contains(T item)
{
bool gotLock = false;
try
{
splock.Enter(ref gotLock);
return list.Contains(item);
}
finally
{
if (gotLock)
{
splock.Exit();
}
}
}
public void CopyTo(T[] array, int arrayIndex)
{
bool gotLock = false;
try
{
splock.Enter(ref gotLock);
list.CopyTo(array, arrayIndex);
}
finally
{
if (gotLock)
{
splock.Exit();
}
}
}
public int Count
{
get
{
System.Threading.Interlocked.Increment(ref lockInt);
try
{
return list.Count;
}
finally
{
System.Threading.Interlocked.Decrement(ref lockInt);
}
}
}
public bool IsReadOnly
{
get { return false; }
}
/// <summary>
/// 从 System.Collections.Generic.List<T> 中移除特定对象的第一个匹配项。
/// </summary>
/// <param name="item">移除特定对象</param>
/// <returns></returns>
public bool Remove(T item)
{
bool gotLock = false;
try
{
splock.Enter(ref gotLock);
return list.Remove(item);
}
finally
{
if (gotLock)
{
splock.Exit();
}
}
}
public IEnumerator<T> GetEnumerator()
{
bool gotLock = false;
try
{
splock.Enter(ref gotLock);
return list.GetEnumerator();
}
finally
{
if (gotLock)
{
splock.Exit();
}
}
}
System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
{
return GetEnumerator();
}
#endregion
/// <summary>
/// 提供一个互斥锁
/// </summary>
System.Threading.SpinLock splock = new System.Threading.SpinLock();
/// <summary>
/// 创建源 System.Collections.Generic.List<T> 中的元素范围的浅表副本。
/// </summary>
/// <param name="index">索引</param>
/// <param name="count">总数</param>
/// <returns></returns>
public List<T> GetRange(int index, int count)
{
bool gotLock = false;
try
{
splock.Enter(ref gotLock);
return list.GetRange(index, count);
}
finally
{
if (gotLock)
{
splock.Exit();
}
}
}
/// <summary>
/// 从 System.Collections.Generic.List<T> 中移除一定范围的元素。
/// </summary>
/// <param name="index">要移除的元素的范围从零开始的起始索引。</param>
/// <param name="count">要移除的元素数</param>
public void RemoveRange(int index, int count)
{
bool gotLock = false;
try
{
splock.Enter(ref gotLock);
list.RemoveRange(index, count);
}
finally
{
if (gotLock)
{
splock.Exit();
}
}
}
}
}