Question

I would like to have thread-safe read and write access to an auto-implemented property. I am missing this functionality from the C#/.NET framework, even in it’s latest version.
At best, I would expect something like

[Threadsafe]
public int? MyProperty { get; set; }

I am aware that there are various code examples to achieve this, but I just wanted to be sure that this is still not possible using .NET framework methods only, before implementing something myself. Am I wrong?

EDIT: As some answers elaborate on atomicity, I want to state that I just want to have that, as far as I understand it: As long as (and not longer than) one thread is reading the value of the property, no other thread is allowed to change the value. So, multi-threading would not introduce invalid values. I chose the int? type because that is the on I am currently concerned about.

EDIT2: I have found the specific answer to the example with Nullable here, by Eric Lippert

Answer 1

Correct; there is no such device. Presumably you are trying to protect against reading the field while another thread has changed half of it (atomicity)? Note that many (small) primitives are inherently safe from this type of threading issue:

5.5 Atomicity of variable references

Reads and writes of the following data
types are atomic: bool, char, byte,
sbyte, short, ushort, uint, int,
float, and reference types. In
addition, reads and writes of enum
types with an underlying type in the
previous list are also atomic.

But in all honesty this is just the tip of the threading ice-berg; by itself it usually isn’t enough to just have a thread-safe property; most times the scope of a synchronized block must be more than just one read/write.

There are also so many different ways of making something thread-safe, depending on the access profile;

• lock ?
• ReaderWriterLockSlim ?
• reference-swapping to some class (essentially a Box<T>, so a Box<int?> in this case)
• Interlocked (in all the guises)
• volatile (in some scenarios; it isn’t a magic wand…)
• etc

(not to mention making it immutable (either through code, or by just choosing not to mutate it, which is often the simplest way of making it thread-safe)