Question

I have a Generic List as below

public static readonly List<Customer> Customers = new List<Customer>();

I’m using the below methods for it:

.Add
.Find
.FirstOrDefault

The last 2 are LINQ extensions.

I’d need to make this thread-safe to be able to run multiple instances of the container class.

How to achieve that?

Answer 1

If those are the only functions you are using on List<T> then the easiest way is to write a quick wrapper that synchronizes access with a lock

class MyList<T> { 
  private List<T> _list = new List<T>();
  private object _sync = new object();
  public void Add(T value) {
    lock (_sync) {
      _list.Add(value);
    }
  }
  public bool Find(Predicate<T> predicate) {
    lock (_sync) {
      return _list.Find(predicate);
    }
  }
  public T FirstOrDefault() {
    lock (_sync) {
      return _list.FirstOrDefault();
    }
  }
}

I highly recommend the approach of a new type + private lock object. It makes it much more obvious to the next guy who inherits your code what the actual intent was.

Also note that .Net 4.0 introduced a new set of collections specifically aimed at being used from multiple threads. If one of these meets your needs I’d highly recommend using it over rolling your own.

• ConcurrentStack<T>
• ConcurrentQueue<T>