事件可以安全地在多线程应用程序中使用吗

Question

在下面的代码中，我有两个类，一个在单独的线程中运行并触发事件，另一个订阅此事件并从事件接收数据。我基于 Jon Skeet 的文章 http://csharpindepth.com/Articles/Chapter2/Events.aspx 的事件代码

在这篇文章http://www.codeproject.com/Articles/37474/Threadsafe-Events 中它说...

出于这个原因，我推荐 Jon Skeet 在 Delegates and Events 最后推荐的相同方法：“不要那样做”，即不要以多线程方式使用事件。如果对象上存在事件，那么只有一个线程应该能够订阅或取消订阅该事件，并且将引发该事件的线程是同一线程。

现在显然我的设计打破了这一点，因为它在与它订阅的线程不同的线程上触发事件。我怎样才能修改我的设计，使其符合不以多线程方式使用事件的原则，或者这是不可能的？

我想到的另一种方法是将我的回调方法作为委托传递给 B 类并调用它而不是调用事件？

我可能有完全错误的一端，所以任何澄清将不胜感激。

注意：我知道 .Net 4.0 显然已经解决了这个问题，但是如果有办法在 .Net 4 之前解决这个问题，我仍然很感兴趣

public delegate void MyDelegate(int a);

class A
{
    void main()
    {
        B bObject = new B();
        bObject.MyEvent += new MyDelegate(NiceMethod);
        bObject.Run();
    }   

    void NiceMethod(int a)
    {   
        Console.Writeline({0}, a);  
    }
}

class B
{
    readonly object eventLock = new object();

    MyDelegate myDel;

    public event MyDelegate MyEvent
    {   
        add
        {
            lock (eventLock)
            {
                myDel += value;
            }
        }
        remove
        {
            lock (eventLock)
            {
                myDel -= value;
            }
        }
    }   

    //Assume this runs in a new thread and calls back data using MyEvent
    //Have ommited thread code for simplicity
    public void Run()
    {
        for (int i = 0; i < 100; i++)
        {
            Thread.Sleep(1000);
            MyDelegate handler;
            lock (someEventLock)
            {
                handler = myDel;
            }
            if (handler != null)
            {
                handler (i);
            }
        }   
    }
}

Answer 1

引发事件或监听来自不同线程的事件没有任何问题。侦听器负责处理从另一个线程调用。正如 Marc Gravell 在他的评论中指出的那样，编译器生成的 add 和 remove 实现支持（并且一直）支持从不同线程的事件中添加和删除监听器。唯一的问题是以线程安全的方式引发事件，这可以通过生成的add 和remove 使用的同一种自旋锁同步对事件的访问来完成：

class B 
{  
    public event MyDelegate MyEvent;

    protected OnMyEvent(int p_Arg)
    {
        // Delegates are immutable and add/remove default
        // implementations always generate a new instance of the 
        // delegate. Therefore, tTmp (if not null) can be safely invoked
        var tTmp = 
            System.Threading.Interlocked
            .CompareExchange(ref MyEvent, null, null);
        if (tTmp != null) {
            tTmp(p_Arg);
        }
    }

    //Assume this runs in a new thread and calls back data using MyEvent 
    //Have ommited thread code for simplicity 
    public void Run() 
    { 
        for (int i = 0; i < 100; i++) 
        { 
            OnMyEvent(i);
        }    
    } 
} 

唯一可能发生的情况是侦听器在从事件列表中删除之后被调用。恕我直言，侦听器必须能够处理这种情况，因为它处理从不同线程调用的beeing...