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: 
If you are targetting .Net 4 there are a few options in [System.Collections.Concurrent](http://msdn.microsoft.com/en-us/library/system.collections.concurrent.aspx) Namespace

You could use `ConcurrentBag<T>` in this case instead of `List<T>`
Basically if you want to enumerate safely, you need to use lock.

Please refer to MSDN on this. <http://msdn.microsoft.com/en-us/library/6sh2ey19.aspx>

Here is part of MSDN that you might be interested:

Public static (Shared in Visual Basic) members of this type are thread safe. Any instance members are not guaranteed to be thread safe.

A List can support multiple readers concurrently, as long as the collection is not modified. Enumerating through a collection is intrinsically not a thread-safe procedure. In the rare case where an enumeration contends with one or more write accesses, the only way to ensure thread safety is to lock the collection during the entire enumeration. To allow the collection to be accessed by multiple threads for reading and writing, you must implement your own synchronization.