Question: I want an implementation of `List<T>` as a property which can be used thread-safely without any doubt.

Something like this:

```
private List<T> _list;

private List<T> MyT
{
    get { // return a copy of _list; }
    set { _list = value; }
}

```

It seems still I need to return a copy (cloned) of collection so if somewhere we are iterating the collection and at the same time the collection is set, then no exception is raised.

How to implement a thread-safe collection property?

Answer: 
Even as it got the most votes, one usually can't take `System.Collections.Concurrent.ConcurrentBag<T>` as a thread-safe replacement for `System.Collections.Generic.List<T>` as it is (Radek Stromský already pointed it out) not ordered.

But there is a class called `System.Collections.Generic.SynchronizedCollection<T>` that is already since .NET 3.0 part of the framework, but it is that well hidden in a location where one does not expect it that it is little known and probably you have never ever stumbled over it (at least I never did).

`SynchronizedCollection<T>` is compiled into assembly **System.ServiceModel.dll** (which is part of the client profile but not of the portable class library).
It seems like many of the people finding this are wanting a thread safe indexed dynamically sized collection. The closest and easiest thing I know of would be.

```
System.Collections.Concurrent.ConcurrentDictionary<int, YourDataType>

```

This would require you to ensure your key is properly incremented if you want normal indexing behavior. If you are careful `.count()` could suffice as the key for any new key value pairs you add.