C# 中实现安全集合Concurrent 支持删除指定元素的

ConcurrentBag实现了IProducerConsumerCollection接口，该接口主要用于生产者消费者模式下，可见该类基本就是为生产消费者模式定制的。然后还实现了常规的IReadOnlyCollection类，实现了该类就需要实现IEnumerable、IEnumerable、 ICollection类。

ConcurrentBag对外提供的方法没有List那么多，但是同样有Enumerable实现的扩展方法。类本身提供的方法如下所示。

名称 说明
Add 将对象添加到 ConcurrentBag 中。
CopyTo 从指定数组索引开始，将 ConcurrentBag 元素复制到现有的一维 Array 中。
Equals(Object) 确定指定的 Object 是否等于当前的 Object。 （继承自 Object。）
Finalize 允许对象在“垃圾回收”回收之前尝试释放资源并执行其他清理操作。 （继承自 Object。）
GetEnumerator 返回循环访问 ConcurrentBag 的枚举器。
GetHashCode 用作特定类型的哈希函数。 （继承自 Object。）
GetType 获取当前实例的 Type。 （继承自 Object。）
MemberwiseClone 创建当前 Object 的浅表副本。 （继承自 Object。）
ToArray 将 ConcurrentBag 元素复制到新数组。
ToString 返回表示当前对象的字符串。 （继承自 Object。）
TryPeek 尝试从 ConcurrentBag 返回一个对象但不移除该对象。
TryTake 尝试从 ConcurrentBag 中移除并返回对象。

该官网提供集合，不支持删除指定对象，因此自己 使用list 和lock 实现线程安全 集合类型

using System.Collections;

namespace TestLib;

public class ConcurrentList<T> : IList<T>
{
    private readonly IList<T> _list = new List<T>();


    private readonly ReaderWriterLockSlim _lock = new ReaderWriterLockSlim(LockRecursionPolicy.NoRecursion);


    public ConcurrentList()
    {

    }

    public ConcurrentList(List<T> values)
    {
        _list = values;
    }


    private void ConcurrentAction(Action<IList<T>> action)
    {
        ConcurrentAction(x => x.EnterWriteLock(), x => x.ExitWriteLock(), action);
    }

    private void ConcurrentAction(Action<ReaderWriterLockSlim> enter
          , Action<ReaderWriterLockSlim> exit, Action<IList<T>> action)
    {
        try
        {
            enter(_lock);
            action(_list);
        }
        finally
        {
            exit(_lock);
        }
    }

    private TResult ConcurrentFunc<TResult>(Func<IList<T>, TResult> func)
          => ConcurrentFunc(x => x.EnterReadLock(), x => x.ExitReadLock(), func);

    private TResult ConcurrentFunc<TResult>(Action<ReaderWriterLockSlim> enter
          , Action<ReaderWriterLockSlim> exit, Func<IList<T>, TResult> func)
    {
        try
        {
            enter(_lock);
            return func(_list);
        }
        finally
        {
            exit(_lock);
        }
    }


    public void AddRange(IEnumerable<T> values)
    {
        ConcurrentAction(l =>
        {
            foreach (var value in values)
            {
                l.Add(value);
            }
        });
    }


    public void Add(T item) => ConcurrentAction(l => l.Add(item));


    public bool Remove(T item) => ConcurrentFunc(l => l.Remove(item));


    public void Clear() => ConcurrentAction(l => l.Clear());


    public bool Contains(T item) => ConcurrentFunc(l => l.Contains(item));


    public void CopyTo(T[] array, int arrayIndex) => ConcurrentAction(l => l.CopyTo(array, arrayIndex));


    public int Count => ConcurrentFunc(l => l.Count);


    public bool IsReadOnly => ConcurrentFunc(l => l.IsReadOnly);


    public int IndexOf(T item) => ConcurrentFunc(l => l.IndexOf(item));


    public void Insert(int index, T item) => ConcurrentAction(l => l.Insert(index, item));


    public void RemoveAt(int index) => ConcurrentAction(l => l.RemoveAt(index));


    public T this[int index]
    {
        get => ConcurrentFunc(l => l[index]);
        set => ConcurrentAction(l => l[index] = value);
    }



    IEnumerator<T> IEnumerable<T>.GetEnumerator()
    {
        return new ConcurrentEnumerator<T>(_list, _lock);
    }

    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
    {
        return new ConcurrentEnumerator<T>(_list, _lock);
    }
}


class ConcurrentEnumerator<T> : System.Collections.Generic.IEnumerator<T>
{

    private readonly ReaderWriterLockSlim _lock;


    private readonly IEnumerator<T> _enumerator;

    internal ConcurrentEnumerator(IEnumerable<T> target, ReaderWriterLockSlim lockSlim)
    {
        _lock = lockSlim;
        _lock.EnterReadLock();
        _enumerator = target.GetEnumerator();
    }


    public T Current => _enumerator.Current;


    public bool MoveNext()
    {
        return _enumerator.MoveNext();
    }


    public void Reset()
    {
        _enumerator.Reset();
    }


    public void Dispose()
    {
        _lock.ExitReadLock();
    }

    object IEnumerator.Current => Current;
}