"how to easy make this counter property thread safe?" Code Answer

if you're looking to implement the property in such a way that donecounter = donecounter + 1 is guaranteed not to be subject to race conditions, it can't be done in the property's implementation. that operation is not atomic, it actually three distinct steps:

1. retrieve the value of donecounter.
2. add 1
3. store the result in donecounter.

you have to guard against the possibility that a context switch could happen in between any of those steps. locking inside the getter or setter won't help, because that lock's scope exists entirely within one of the steps (either 1 or 3). if you want to make sure all three steps happen together without being interrupted, then your synchronization has to cover all three steps. which means it has to happen in a context that contains all three of them. that's probably going to end up being code that does not belong to whatever class contains the donecounter property.

it is the responsibility of the person using your object to take care of thread safety. in general, no class that has read/write fields or properties can be made "thread-safe" in this manner. however, if you can change the class's interface so that setters aren't necessary, then it is possible to make it more thread-safe. for example, if you know that donecounter only increments and decrements, then you could re-implement it like so:

private int _donecounter;
public int donecounter { get { return _donecounter; } }
public int incrementdonecounter() { return interlocked.increment(ref _donecounter); }
public int decrementdonecounter() { return interlocked.decrement(ref _donecounter); }