对于单线程应用程序，你是正确的，这不是一个问题。

但是，如果您正在制作一个公开事件的组件，则无法保证组件的使用者不会采用多线程，在这种情况下，您需要做好最坏的准备。

使用空委托确实解决了这个问题，但也会在每次调用事件时导致性能下降，并可能涉及GC。

您是对的，消费者试图取消订阅才会发生这种情况，但如果他们通过了临时副本，那么就认为消息已经在传输中。

如果你不使用临时变量，也不使用空委托，有人取消订阅，你会得到一个空引用异常，这是致命的，所以我认为代价是值得的。

我真的很喜欢这篇文章——不是!即使我需要它与称为事件的c#功能一起工作!

为什么不在编译器中修复这个问题呢?我知道有MS的人读了这些帖子，所以请不要激怒它!

1 - Null问题)为什么不让事件是。empty而不是Null在第一个地方?有多少行代码将被保存为空检查或必须在声明中插入= delegate {} ?让编译器处理空的情况，IE什么都不做!如果这对事件的创建者很重要，他们可以检查.Empty并对它做任何他们关心的事情!否则，所有的空检查/委托添加都是围绕这个问题的黑客!

老实说，我厌倦了对每个事件都这样做——又名样板代码!

public event Action<thisClass, string> Some;
protected virtual void DoSomeEvent(string someValue)
{
  var e = Some; // avoid race condition here! 
  if(null != e) // avoid null condition here! 
     e(this, someValue);
}

2 -竞态条件问题)我读了Eric的博客文章，我同意H(处理程序)应该处理当它解引用自己，但不能使事件不可变/线程安全?IE，设置一个锁标志在它的创建，这样每当它被调用，它锁定所有订阅和取消订阅，而它的执行?

结论,

现代语言不应该为我们解决这些问题吗?

对于单线程应用程序，你是正确的，这不是一个问题。

但是，如果您正在制作一个公开事件的组件，则无法保证组件的使用者不会采用多线程，在这种情况下，您需要做好最坏的准备。

使用空委托确实解决了这个问题，但也会在每次调用事件时导致性能下降，并可能涉及GC。

您是对的，消费者试图取消订阅才会发生这种情况，但如果他们通过了临时副本，那么就认为消息已经在传输中。

如果你不使用临时变量，也不使用空委托，有人取消订阅，你会得到一个空引用异常，这是致命的，所以我认为代价是值得的。

所以我来的有点晚了。：）

至于使用null而不是null对象模式来表示没有订阅者的事件，请考虑以下场景。您需要调用一个事件，但是构造对象(EventArgs)并非简单，而且在一般情况下，事件没有订阅者。如果您能够优化代码，在进行构造参数和调用事件的处理工作之前检查是否有订阅者，这将对您大有好处。

With this in mind, a solution is to say "well, zero subscribers is represented by null." Then simply perform the null check before performing your expensive operation. I suppose another way of doing this would have been to have a Count property on the Delegate type, so you'd only perform the expensive operation if myDelegate.Count > 0. Using a Count property is a somewhat nice pattern that solves the original problem of allowing optimization, and it also has the nice property of being able to be invoked without causing a NullReferenceException.

但是请记住，由于委托是引用类型，所以它们可以为空。也许根本没有好办法隐藏这一事实，只支持事件的空对象模式，所以替代方案可能迫使开发人员同时检查空订阅者和零订阅者。那将比目前的情况更糟糕。

注:这纯粹是猜测。我不涉及。net语言或CLR。

此实践并不是关于强制执行操作的特定顺序。它实际上是关于避免空引用异常。

人们关心空引用异常而不是竞争条件背后的原因需要一些深入的心理学研究。我认为这与修复空引用问题要容易得多有关。一旦这个问题解决了，他们就会在代码上挂一个大大的“任务完成”的横幅，然后打开他们的飞行服。

注意:修复竞态条件可能涉及使用同步标志跟踪处理程序是否应该运行

谢谢你的有益讨论。我最近正在处理这个问题，并制作了下面的类，它有点慢，但允许避免调用已处置对象。

这里的要点是，即使发生事件，调用列表也可以被修改。

/// <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#中实现线程安全事件是可能的。

你怎么看?