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).
Looking at the original sample one may guess that the intention was to be able to simply replace the list with the new one. The setter on the property tells us about it.

The Micrisoft's Thread-Safe Collections are for safely adding and removing items from collection. But if in the application logic you are intending to replace the collection with the new one, one may guess, again, that the adding and deleting functionality of the List is not required.

If this is the case then, the simple answer would be to use IReadOnlyList interface:

```
 private IReadOnlyList<T> _readOnlyList = new List<T>();

    private IReadOnlyList<T> MyT
    {
       get { return _readOnlyList; }
       set { _readOnlyList = value; }
    }

```

One doesn't need to use any locking in this situation because there is no way to modify the collection. If in the setter the "\_readOnlyList = value;" will be replaced by something more complicated then the lock could be required.