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: 
I would suggest anyone dealing with a `List<T>` in multi-threading scenarios to take look at [Immutable Collections](https://learn.microsoft.com/en-us/dotnet/api/system.collections.immutable?view=netcore-2.2) in particular the [ImmutableArray](https://learn.microsoft.com/en-us/dotnet/api/system.collections.immutable.immutablearray?view=netcore-2.2).

I've found it very useful when you have:

1. Relatively few items in the list
2. Not so many read/write operations
3. A LOT of concurrent access (i.e. many threads that access the list in reading mode)

Also can be useful when you need to implement some sort of transaction-like behavior (i.e. revert an insert/update/delete operation in case of fail)
I believe `_list.ToList()` will make you a copy. You can also query it if you need to such as :

```
_list.Select("query here").ToList(); 

```

Anyways, msdn says this is indeed a copy and not simply a reference. Oh, and yes, you will need to lock in the set method as the others have pointed out.