我经常听到/读到以下建议:
在检查事件是否为空并触发它之前，始终要对事件进行复制。这将消除线程的一个潜在问题，即事件在你检查null和你触发事件的位置之间变成null:
// Copy the event delegate before checking/calling
EventHandler copy = TheEvent;
if (copy != null)
copy(this, EventArgs.Empty); // Call any handlers on the copied list
更新:我认为从阅读优化，这可能也需要事件成员是volatile，但Jon Skeet在他的回答中说，CLR不会优化掉副本。
但与此同时，为了让这个问题发生，另一个线程必须做这样的事情:
// Better delist from event - don't want our handler called from now on:
otherObject.TheEvent -= OnTheEvent;
// Good, now we can be certain that OnTheEvent will not run...
实际的序列可能是这样的:
// Copy the event delegate before checking/calling
EventHandler copy = TheEvent;
// Better delist from event - don't want our handler called from now on:
otherObject.TheEvent -= OnTheEvent;
// Good, now we can be certain that OnTheEvent will not run...
if (copy != null)
copy(this, EventArgs.Empty); // Call any handlers on the copied list
重点是OnTheEvent运行后，作者已经取消订阅，但他们只是取消订阅专门避免这种情况发生。当然，真正需要的是在添加和删除访问器中具有适当同步的自定义事件实现。此外，如果在触发事件时持有锁，则可能存在死锁的问题。
So is this Cargo Cult Programming? It seems that way - a lot of people must be taking this step to protect their code from multiple threads, when in reality it seems to me that events require much more care than this before they can be used as part of a multi-threaded design. Consequently, people who are not taking that additional care might as well ignore this advice - it simply isn't an issue for single-threaded programs, and in fact, given the absence of volatile in most online example code, the advice may be having no effect at all.
(在成员声明中分配空委托{}不是更简单吗，这样你就永远不需要在第一时间检查null ?)
Updated: In case it wasn't clear, I did grasp the intention of the advice - to avoid a null reference exception under all circumstances. My point is that this particular null reference exception can only occur if another thread is delisting from the event, and the only reason for doing that is to ensure that no further calls will be received via that event, which clearly is NOT achieved by this technique. You'd be concealing a race condition - it would be better to reveal it! That null exception helps to detect an abuse of your component. If you want your component to be protected from abuse, you could follow the example of WPF - store the thread ID in your constructor and then throw an exception if another thread tries to interact directly with your component. Or else implement a truly thread-safe component (not an easy task).
所以我认为，仅仅做这种复制/检查的习惯是盲目的编程，会给你的代码增加混乱和噪音。要真正防范其他线程，需要做更多的工作。
针对Eric Lippert博客文章的更新:
因此，关于事件处理程序，我错过了一个主要的事情:“事件处理程序必须健壮，即使在事件被取消订阅后也需要被调用”，显然，因此我们只需要关心事件委托为空的可能性。对事件处理程序的需求在任何地方都有记录吗?
所以:“有其他方法可以解决这个问题;例如，初始化处理程序以拥有一个永远不会删除的空操作。但做空检查是标准模式。”
所以我的问题剩下的一个片段是，为什么显式空检查是“标准模式”?另一种方法，分配空委托，只需要将= delegate{}添加到事件声明中，这就消除了每个引发事件的地方的那些臭仪式。可以很容易地确保实例化空委托的成本很低。还是我还遗漏了什么?
当然，就像Jon Skeet所建议的那样，这只是。net 1。X条没有消失的建议，就像它在2005年应该消失的那样?
更新
从c# 6开始，这个问题的答案是:
SomeEvent?.Invoke(this, e);
谢谢你的有益讨论。我最近正在处理这个问题，并制作了下面的类，它有点慢，但允许避免调用已处置对象。
这里的要点是，即使发生事件，调用列表也可以被修改。
/// <summary>
/// Thread safe event invoker
/// </summary>
public sealed class ThreadSafeEventInvoker
{
/// <summary>
/// Dictionary of delegates
/// </summary>
readonly ConcurrentDictionary<Delegate, DelegateHolder> delegates = new ConcurrentDictionary<Delegate, DelegateHolder>();
/// <summary>
/// List of delegates to be called, we need it because it is relatevely easy to implement a loop with list
/// modification inside of it
/// </summary>
readonly LinkedList<DelegateHolder> delegatesList = new LinkedList<DelegateHolder>();
/// <summary>
/// locker for delegates list
/// </summary>
private readonly ReaderWriterLockSlim listLocker = new ReaderWriterLockSlim();
/// <summary>
/// Add delegate to list
/// </summary>
/// <param name="value"></param>
public void Add(Delegate value)
{
var holder = new DelegateHolder(value);
if (!delegates.TryAdd(value, holder)) return;
listLocker.EnterWriteLock();
delegatesList.AddLast(holder);
listLocker.ExitWriteLock();
}
/// <summary>
/// Remove delegate from list
/// </summary>
/// <param name="value"></param>
public void Remove(Delegate value)
{
DelegateHolder holder;
if (!delegates.TryRemove(value, out holder)) return;
Monitor.Enter(holder);
holder.IsDeleted = true;
Monitor.Exit(holder);
}
/// <summary>
/// Raise an event
/// </summary>
/// <param name="args"></param>
public void Raise(params object[] args)
{
DelegateHolder holder = null;
try
{
// get root element
listLocker.EnterReadLock();
var cursor = delegatesList.First;
listLocker.ExitReadLock();
while (cursor != null)
{
// get its value and a next node
listLocker.EnterReadLock();
holder = cursor.Value;
var next = cursor.Next;
listLocker.ExitReadLock();
// lock holder and invoke if it is not removed
Monitor.Enter(holder);
if (!holder.IsDeleted)
holder.Action.DynamicInvoke(args);
else if (!holder.IsDeletedFromList)
{
listLocker.EnterWriteLock();
delegatesList.Remove(cursor);
holder.IsDeletedFromList = true;
listLocker.ExitWriteLock();
}
Monitor.Exit(holder);
cursor = next;
}
}
catch
{
// clean up
if (listLocker.IsReadLockHeld)
listLocker.ExitReadLock();
if (listLocker.IsWriteLockHeld)
listLocker.ExitWriteLock();
if (holder != null && Monitor.IsEntered(holder))
Monitor.Exit(holder);
throw;
}
}
/// <summary>
/// helper class
/// </summary>
class DelegateHolder
{
/// <summary>
/// delegate to call
/// </summary>
public Delegate Action { get; private set; }
/// <summary>
/// flag shows if this delegate removed from list of calls
/// </summary>
public bool IsDeleted { get; set; }
/// <summary>
/// flag shows if this instance was removed from all lists
/// </summary>
public bool IsDeletedFromList { get; set; }
/// <summary>
/// Constuctor
/// </summary>
/// <param name="d"></param>
public DelegateHolder(Delegate d)
{
Action = d;
}
}
}
用法是:
private readonly ThreadSafeEventInvoker someEventWrapper = new ThreadSafeEventInvoker();
public event Action SomeEvent
{
add { someEventWrapper.Add(value); }
remove { someEventWrapper.Remove(value); }
}
public void RaiseSomeEvent()
{
someEventWrapper.Raise();
}
Test
我用以下方式测试了它。我有一个线程，它创建和破坏对象，像这样:
var objects = Enumerable.Range(0, 1000).Select(x => new Bar(foo)).ToList();
Thread.Sleep(10);
objects.ForEach(x => x.Dispose());
在一个酒吧(监听器对象)构造函数中，我订阅SomeEvent(如上所示实现)并在Dispose中取消订阅:
public Bar(Foo foo)
{
this.foo = foo;
foo.SomeEvent += Handler;
}
public void Handler()
{
if (disposed)
Console.WriteLine("Handler is called after object was disposed!");
}
public void Dispose()
{
foo.SomeEvent -= Handler;
disposed = true;
}
我也有两个线程在循环中引发事件。
所有这些操作都是同时执行的:创建和销毁许多侦听器，同时触发事件。
如果有一个竞争条件，我应该看到一个消息在控制台，但它是空的。但是如果我像往常一样使用clr事件，我看到它充满了警告消息。因此，我可以得出结论，在c#中实现线程安全事件是可能的。
你怎么看?
