Hogyan lehet könnyen threadsafe eseményt kezelni.

 https://codeblog.jonskeet.uk/2015/01/30/clean-event-handlers-invocation-with-c-6/

What is this thing you call thread-safe?

The code we’ve got so far is “thread-safe” in that it doesn’t matter what other threads do – you won’t get a NullReferenceException from the above code. However, if other threads are subscribing to the event or unsubscribing from it, you might not see the most recent changes for the normal reasons of memory models being complicated.

As of C# 4, field-like events are implemented using Interlocked.CompareExchange, so we can just use a corresponding Interlocked.CompareExchange call to make sure we get the most recent value. There’s nothing new about being able to do that, admittedly, but it does mean we can just write:

1 2 3 4

public void OnFoo() {     Interlocked.CompareExchange(ref Foo, null, null)?.Invoke(this, EventArgs.Empty); }

with no other code, to invoke the absolute latest set of event subscribers, without failing if a NullReferenceException is thrown. Thanks to David Fowler for reminding me about this aspect.

Admittedly the CompareExchange call is ugly. In .NET 4.5 and up, there’s Volatile.Read which may do the tricky, but it’s not entirely clear to me (based on the documentation) whether it actually does the right thing. (The summary suggests it’s about preventing the movement of later reads/writes earlier than the given volatile read; we want to prevent earlier writes from being moved later.)

1 2 3 4 5

public void OnFoo() {     // .NET 4.5+, may or may not be safe...     Volatile.Read(ref Foo)?.Invoke(this, EventArgs.Empty); }

… but that makes me nervous in terms of whether I’ve missed something. Expert readers may well be able to advise me on why this is sufficiently foolish that it’s not in the BCL.

An alternative approach

One alternative approach I’ve used in the past is to create a dummy event handler, usually using the one feature that anonymous methods have over lambda expressions – the ability to indicate that you don’t care about the parameters by not even specifying a parameter list:

1 2 3 4 5 6 7

public event EventHandler Foo = delegate {}   public void OnFoo() {     // Foo will never be null     Volatile.Read(ref Foo).Invoke(this, EventArgs.Empty);   }

This has all the same memory barrier issues as before, but it does mean you don’t have to worry about the nullity aspect. It looks a little odd and presumably there’s a tiny performance penalty, but it’s a good alternative option to be aware of.