Of course you are right, but this is generally the case with all “thread safe” classes. We can attempt to guarantee all of our public methods are safe to call concurrently from separate threads, but there’s no way to ensure that *multiple calls* from one thread happen before calls from another. In this scenario you will require an external lock.

The reason I generally use “thread safe” in quotes is partly for this reason. We can do our best to make our internals safe, but you still need to make sure that your calling code isn’t doing anything inherently unsafe.

The code you pasted won’t error, you just might not end up with quite the value you expect, but even with your locks in place another thread may overwrite your new value immediately, so the lock in your example seems to add little value.

Thanks,

Steve

What happens if somebody call the below code from multiple threads

if(safeDictionaryObj["MyKey"] == “SomeValue”)
{
safeDictionaryObj["MyKey"] = “NewValue”;
}

It won’t be working as expected, so we may have to lock the entire if statement again to make it thread safe.

lock(__alockobj)
{
if(safeDictionaryObj["MyKey"] == “SomeValue”)
{
safeDictionaryObj["MyKey"] = “NewValue”;
}
}

So the composition class you have created may not holds good for this scenario.