Is the null coalescing operator (??) in C# thread-safe?

Question

Is there a race condition in the following code that could result in a `NullReferenceException`? -- or -- Is it possible for the `Callback` variable to be set to null after the null coalescing operator checks for a null value but before the function is invoked? ``` class MyClass { public Action Callback { get; set; } public void DoCallback() { (Callback ?? new Action(() => { }))(); } } ``` EDIT This is a question that arose out of curiosity. I don't normally code this way. I'm not worried about the `Callback` variable becoming stale. I'm worried about an `Exception` being thrown from `DoCallback`. EDIT #2 Here is my class: ``` class MyClass { Action Callback { get; set; } public void DoCallbackCoalesce() { (Callback ?? new Action(() => { }))(); } public void DoCallbackIfElse() { if (null != Callback) Callback(); else new Action(() => { })(); } } ``` The method `DoCallbackIfElse` has a race condition that may throw a `NullReferenceException`. Does the `DoCallbackCoalesce` method have t…

Accepted Answer

```
public void DoCallback() {
    (Callback ?? new Action(() => { }))();
}
```

is guaranteed to be equivalent to:

```
public void DoCallback() {
    Action local = Callback;
    if (local == null)
       local = new Action(() => { });
    local();
}
```

Whether this may cause a NullReferenceException depends on the memory model. The Microsoft .NET framework memory model is documented to never introduce additional reads, so the value tested against `null` is the same value that will be invoked, and your code is safe. However, the ECMA-335 CLI memory model is less strict and allows the runtime to eliminate the local variable and access the `Callback` field twice (I'm assuming it's a field or a property that accesses a simple field).

You should mark the `Callback` field `volatile` to ensure the proper memory barrier is used - this makes the code safe even in the weak ECMA-335 model.

If it's not performance critical code, just use a lock (reading Callback into a local variable inside the lock is sufficient, you don't need to hold the lock while invoking the delegate) - anything else requires detailed knowledge about memory models to know whether it is safe, and the exact details might change in future .NET versions (unlike Java, Microsoft hasn't fully specified the .NET memory model).

Is the null coalescing operator (??) in C# thread-safe?

Solution

Problem

Related problems