Uma prática comum para evitar condições de corrida (em aplicativos multiencadeados) ao acionar eventos é esta:

EventHandler<EventArgs> temp = SomeEvent;
if (temp != null) temp(e);

"Remember that delegates are immutable and this is why this technique works in theory. However, what a lot of developers don't realize is that this code could be optimized by the compiler to remove the local temp variable entirely. If this happens, this version of the code is identical to the first version, so a NullReferenceException is still possible."

O problema (de acordo com o livro) é que "esse código poderia ser otimizado pelo compilador para remover completamente a variável temp local. Se isso acontecer, essa versão do código é idêntica à primeira versão, portanto, uma NullReferenceException ainda é possível"

Acordo com o CLR via C #, aqui é uma maneira melhor para forçar o compilador para copiar o ponteiro de evento.

virtual void OnNewMail(NewMailEventArgs e)
{
    EventHandler<NewMailEventArgs> temp =
                          Interlocked.CompareExchange(ref NewMail, null, null);
    if (temp != null) 
        temp(this, e);
}

Aqui, o CompareExchange altera a referência NewMail para null se for nula e não altera NewMail se não for nula. Em outras palavras, o CompareExchange não altera o valor do NewMail, mas retorna o valor dentro do NewMail de maneira atômica e segura para thread. Richter, Jeffrey (2010-02-12). CLR via C # (p. 265). OReilly Media - A. Kindle Edition.

Estou no .net 4.0 framework, e não sei como isso pode possivelmente funcionar, porque Interlocked.CompareExchange espera uma referência a um local, não uma referência a um evento.

Ou há um erro no livro ou eu interpretei mal. Alguém implementou esse método? Ou tem uma maneira melhor de evitar condições de corrida aqui?

ATUALIZAR

foi meu erro, o código iterlocked funciona. Eu só tinha especificado errado, mas de acordo com Bradley (abaixo), não é necessário em .net 2.0 e até no Windows.