虚拟事件在 C# 中如何工作？

Question

以下是我用于测试的程序。 它打印（如预期）：

Raise A
Event from A
Raise B
Event from B

现在，如果我们将 Main 的前两行更改为：

        A a = new B();
        B b = new B();

程序将打印：

Raise A
Raise B
Event from B

这也是预期的，因为重写事件隐藏了基类中的私有支持字段，因此基类触发的事件对派生类的客户端不可见。

现在我将相同的行更改为：

 B b = new B();
 A a = b;

程序开始打印：

Raise A
Raise B
Event from A
Event from B

发生什么事了？

class A
{
    public virtual event EventHandler VirtualEvent;
    public void RaiseA()
    {
        Console.WriteLine("Raise A");
        if (VirtualEvent != null)
        {
            VirtualEvent(this, EventArgs.Empty);
        }
    }
}
class B : A
{
    public override event EventHandler VirtualEvent;
    public void RaiseB()
    {
        Console.WriteLine("Raise B");             
        if (VirtualEvent != null)
        {
            VirtualEvent(this, EventArgs.Empty);
        }
    }
}

class Program
{
    static void Main(string[] args)
    {
        A a = new A();
        B b = new B();

        a.VirtualEvent += (s, e) => Console.WriteLine("Event from A");
        b.VirtualEvent += (s, e) => Console.WriteLine("Event from B");

        a.RaiseA();
        b.RaiseB();
    }
}

Answer 1

我们有一个（B 的）实例，它具有以下字段：

• A.VirtualEvent：空
• B.VirtualEvent：两个事件处理程序

对

a.RaiseA()

just 的调用会打印“Raise A” - 但仅此而已，因为 A 中的私有字段为空。

对

b.RaiseB()

的调用会打印剩余的三行，因为该事件已订阅两次（一次打印“来自 A 的事件”，一次打印“来自 B 的事件”）。

这有帮助吗？

编辑：为了更清楚 - 将虚拟事件视为一对虚拟方法。非常像这样：

public class A
{
    private EventHandler handlerA;

    public virtual void AddEventHandler(EventHandler handler)
    {
        handlerA += handler;
    }

    public virtual void RemoveEventHandler(EventHandler handler)
    {
        handlerA -= handler;
    }

    // RaiseA stuff
}

public class B : A
{
    private EventHandler handlerB;

    public override void AddEventHandler(EventHandler handler)
    {
        handlerB += handler;
    }

    public override void RemoveEventHandler(EventHandler handler)
    {
        handlerB -= handler;
    }

    // RaiseB stuff
}

现在清楚了吗？它并不完全像那样，因为据我所知，您不能仅覆盖事件的“部分”（即方法之一），但它给出了正确的总体印象。

Answer 2

TWO

处理程序已连接到它，因此它首先打印 Raise B，当事件触发时，两个处理程序都会被调用。

Answer 3

经验法则：如果派生类重写事件访问器，它还必须重写调用事件的函数。