为什么 C# 要求您在每次触发事件时编写空检查？

Question

这对我来说似乎很奇怪——VB.NET 通过其 RaiseEvent 关键字隐式处理 null 检查。它似乎大大增加了围绕事件的样板数量，但我看不出它能带来什么好处。

我确信语言设计者有充分的理由这样做......但我很好奇是否有人知道为什么。

Answer 1

这确实是一个令人烦恼的地方。

当您编写访问类中类似字段的事件的代码时，您实际上是在访问该字段本身（对 C# 4 中的一些更改进行取模；我们暂时不去那里）。

因此，选项是：

• 特殊情况的类似字段的事件调用，这样它们实际上并不直接引用该字段，而是添加了一个包装器

• 以不同的方式处理所有委托调用，这样：

  操作; x = 空；
  x();
  

  不会抛出异常。

当然，对于非 void 委托（和事件），这两个选项都会引发一个问题：

Func<int> x = null;
int y = x();

是否应该默默返回 0？ （int 的默认值。）或者它实际上掩盖了错误（更有可能）。让它默默地忽略您试图调用空委托的事实会有些不一致。在这种情况下，情况会更奇怪，因为它不使用 C# 的语法糖：

Func<int> x = null;
int y = x.Invoke();

基本上，无论你做什么，事情都会变得棘手并且与语言的其余部分不一致。我也不喜欢它，但我不确定实用但一致的解决方案可能是什么......

Answer 2

我们通常通过这样声明我们的事件来解决这个问题：

public event EventHandler<FooEventArgs> Foo = delegate { };

这有两个优点。首先是我们没有检查 null 。第二个是我们避免了典型事件触发中普遍存在的关键部分问题：

// old, busted code that happens to work most of the time since
// a lot of code never unsubscribes from events
protected virtual void OnFoo(FooEventArgs e)
{
    // two threads, first checks for null and succeeds and enters
    if (Foo != null) {
        // second thread removes event handler now, leaving Foo = null
        // first thread resumes and crashes.
        Foo(this, e);
    }
}

// proper thread-safe code
protected virtual void OnFoo(FooEventArgs e)
{
     EventHandler<FooEventArgs> handler = Foo;
     if (handler != null)
         handler(this, e);
}

但是通过将 Foo 自动初始化为空委托，永远不需要任何检查，并且代码自动是线程安全的，并且更易于阅读boot：

protected virtual void OnFoo(FooEventArgs e)
{
    Foo(this, e); // always good
}

向《空手道小子》中的帕特·森田致歉，“避免 null 的最好方法就是不拥有一个。”

至于原因，C# 不像 VB 那样宠溺你。尽管 event 关键字隐藏了多播委托的大部分实现细节，它确实为您提供了比 VB 更好的控制。

Answer 3

您需要考虑如果首先设置引发事件的管道会很昂贵（如 SystemEvents），或者准备事件参数会很昂贵（如 Paint 事件），则需要哪些代码。

Visual Basic 风格的事件处理不允许您推迟支持此类事件的成本。您无法覆盖添加/删除访问器来延迟将昂贵的管道安装到位。而且您无法发现可能没有订阅任何事件处理程序，因此燃烧周期来准备事件参数是浪费时间。

在 C# 中不是问题。便利性和控制之间的经典权衡。

Answer 4

扩展方法提供了一种非常酷的方法来解决这个问题。考虑以下代码：

static public class Extensions
{
    public static void Raise(this EventHandler handler, object sender)
    {
        Raise(handler, sender, EventArgs.Empty);
    }

    public static void Raise(this EventHandler handler, object sender, EventArgs args)
    {
        if (handler != null) handler(sender, args);
    }

    public static void Raise<T>(this EventHandler<T> handler, object sender, T args)
        where T : EventArgs
    {
        if (handler != null) handler(sender, args);
    }
}

现在您可以简单地执行此操作：

class Test
{
    public event EventHandler SomeEvent;

    public void DoSomething()
    {
        SomeEvent.Raise(this);
    }
}

但是，正如其他人已经提到的，您应该意识到多线程场景中可能出现的竞争条件。

Answer 5

真的不知道为什么这样做，但是有一个 空对象模式 的变体对于代表：

private event EventHandler Foo = (sender, args) => {};

这样您就可以自由调用 Foo，而无需检查 null。

Answer 6

因为 RaiseEvent 会带来一些开销。

控制和易用性之间总是需要权衡。

• VB.Net：易于使用，
• C#：与 VB 一样具有更多控制能力
• C++：更多控制，更少指导，更容易搬起石头砸自己的脚

Answer 7

编辑：正如OP指出的那样，这个答案没有解决问题的正文。然而，有些人可能会发现它很有用，因为它确实提供了问题标题的答案（单独使用时）：

为什么 C# 要求您在每次触发事件时编写空检查？

它还提供了问题正文的意图的背景，有些人可能会觉得有用。因此，出于这些原因以及 Meta 上的此建议，我将保留这个答案。

---

原文：

在其 MSDN 文章中 如何：发布符合 .NET Framework 准则的事件（C# 编程指南）(Visual Studio 2013)，Microsoft 在其示例中包含以下注释：

// Make a temporary copy of the event to avoid possibility of 
// a race condition if the last subscriber unsubscribes 
// immediately after the null check and before the event is raised.

Here is a微软示例代码的较大摘录，提供了该评论的上下文。

// Wrap event invocations inside a protected virtual method 
// to allow derived classes to override the event invocation behavior 
protected virtual void OnRaiseCustomEvent(CustomEventArgs e)
{
    // Make a temporary copy of the event to avoid possibility of 
    // a race condition if the last subscriber unsubscribes 
    // immediately after the null check and before the event is raised.
    EventHandler<CustomEventArgs> handler = RaiseCustomEvent;

    // Event will be null if there are no subscribers 
    if (handler != null)
    {
        // Format the string to send inside the CustomEventArgs parameter
        e.Message += String.Format(" at {0}", DateTime.Now.ToString());

        // Use the () operator to raise the event.
        handler(this, e);
    }
}

Answer 8

请注意，从 C# 6 开始，该语言现在提供了一种简洁的语法来方便地执行此 null 检查。例如：

public event EventHandler SomeEvent;

private void M()
{
    // raise the event:
    SomeEvent?.Invoke(this, EventArgs.Empty);
}

请参阅 空条件运算符

Answer 9

原因实际上可以归结为 C# 为您提供了更多控制权。在 C# 中，如果您愿意，则不必执行 null 检查。在下面的代码中，MyEvent 永远不可能是 null 那么为什么还要进行检查呢？

public class EventTest
{
  private event EventHandler MyEvent = delegate { Console.WriteLine("Hello World"); }

  public void Test()
  {
    MyEvent(this, new EventArgs());
  }
}