blocks|key|3143079|text|添加事件处理程序的C#编译器的缺省实现调用Delegate.Combine，而删除事件处理程序的缺省实现调用Delegate.Remove|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3143080|Fire+=+(MyDelegate)+Delegate.Remove(Fire,+new+MyDelegate(Program.OnFire));|code-block|syntax|javascript|3143081|框架的Delegate.Remove实现并不查看MyDelegate对象本身，而是查看委托引用的方法(Program.OnFire)。因此，在取消订阅现有的事件处理程序时，创建一个新的MyDelegate对象是完全安全的。因此，C#编译器允许您在添加/删除事件处理程序时使用简写语法(在幕后生成完全相同的代码)：您可以省略new+MyDelegate部分：|3143082|Fire+%2B=+OnFire;
Fire+-=+OnFire;|3143083|当从事件处理程序中移除最后一个委托时，Delegate.Remove返回null。正如您已经发现的，在引发事件之前必须检查事件是否为null：|3143084|MyDelegate+handler+=+Fire;
if+(handler+!=+null)
++++handler("Hello+3");|3143085|它被分配给一个临时局部变量，以防止其他线程上的取消订阅事件处理程序出现可能的竞争条件。(有关将事件处理程序分配给局部变量的线程安全性的详细信息，请参见my+blog+post。)防止这个问题的另一种方法是创建一个总是订阅的空委托；虽然这使用了更多的内存，但事件处理程序永远不能为空(并且代码可以更简单)：|3143086|public+static+event+MyDelegate+Fire+=+delegate+{+};|3143087|entityMap|0|LINK|mutability|MUTABLE|url|http://code.logos.com/blog/2008/11/events_and_threads_part_4.html^0|L|G|1I|F|0|0|3|F|O|A|1F|E|2K|A|4H|E|0|0|J|F|0|0|23|C|0|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@$9|15|A|16|B|C]|$9|17|A|18|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|19|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1A|8|@$9|1B|A|1C|B|C]|$9|1D|A|1E|B|C]|$9|1F|A|1G|B|C]|$9|1H|A|1I|B|C]|$9|1J|A|1K|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|1L|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|1M|8|@$9|1N|A|1O|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|H|7|1P|8|@]|D|@]|E|$I|J]]|$1|S|3|T|5|6|7|1Q|8|@]|D|@$9|1R|A|1S|1|1T]]|E|$]]|$1|U|3|V|5|H|7|1U|8|@]|D|@]|E|$I|J]]|$1|W|3|-4|5|6|7|1V|8|@]|D|@]|E|$]]]|X|$Y|$5|Z|10|11|E|$12|13]]]]

The C# compiler's default implementation of adding an event handler calls <code>Delegate.Combine</code>, while removing an event handler calls <code>Delegate.Remove</code>:

<pre><code>Fire = (MyDelegate) Delegate.Remove(Fire, new MyDelegate(Program.OnFire));
</code></pre>

The Framework's implementation of <code>Delegate.Remove</code> doesn't look at the <code>MyDelegate</code> object itself, but at the method the delegate refers to (<code>Program.OnFire</code>). Thus, it's perfectly safe to create a new <code>MyDelegate</code> object when unsubscribing an existing event handler. Because of this, the C# compiler allows you to use a shorthand syntax (that generates exactly the same code behind the scenes) when adding/removing event handlers: you can omit the <code>new MyDelegate</code> part:

<pre><code>Fire += OnFire;
Fire -= OnFire;
</code></pre>

When the last delegate is removed from the event handler, <code>Delegate.Remove</code> returns null. As you have found out, it's essential to check the event against null before raising it:

<pre><code>MyDelegate handler = Fire;
if (handler != null)
 handler("Hello 3");
</code></pre>

It's assigned to a temporary local variable to defend against a possible race condition with unsubscribing event handlers on other threads. (See <a href="http://code.logos.com/blog/2008/11/events_and_threads_part_4.html" rel="noreferrer">my blog post</a> for details on the thread safety of assigning the event handler to a local variable.) Another way to defend against this problem is to create an empty delegate that is always subscribed; while this uses a little more memory, the event handler can never be null (and the code can be simpler):

<pre><code>public static event MyDelegate Fire = delegate { };
</code></pre>

blocks|key|3143159|text|在触发委托之前，应该始终检查它是否没有目标(它的值为null)。如前所述，一种方法是订阅一个不做任何事情的匿名方法，该方法不会被删除。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3143160|public+event+MyDelegate+Fire+=+delegate+{};|code-block|syntax|javascript|3143161|然而，这只是一个避免NullReferenceExceptions的黑客攻击。|3143162|只需在调用is+not+threadsafe之前检查委托是否为null，因为其他线程可以在null检查后注销，并在调用时将其设为null。还有一种解决方案是将委托复制到临时变量中：|3143163|public+event+MyDelegate+Fire;
public+void+FireEvent(string+msg)
{
++++MyDelegate+temp+=+Fire;
++++if+(temp+!=+null)
++++++++temp(msg);
}|3143164|不幸的是，JIT编译器可能会优化代码，删除临时变量，并使用原始委托。(根据Juval+Lowy+-+Programming+.NET+Components)|3143165|因此，为了避免这个问题，您可以使用接受委托作为参数的方法：|3143166|[MethodImpl(MethodImplOptions.NoInlining)]
public+void+FireEvent(MyDelegate+fire,+string+msg)
{
++++if+(fire+!=+null)
++++++++fire(msg);
}|3143167|请注意，如果没有MethodImpl(NoInlining)属性，JIT编译器可能会内联该方法，使其毫无价值。因为委托是不可变的，所以这个实现是threadsafe的。您可以按如下方式使用此方法：|3143168|FireEvent(Fire,"Hello+3");|3143169|entityMap^0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|10|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|11|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|12|8|@]|9|@]|A|$E|F]]|$1|M|3|N|5|6|7|13|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|14|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|15|8|@]|9|@]|A|$E|F]]|$1|S|3|T|5|6|7|16|8|@]|9|@]|A|$]]|$1|U|3|V|5|D|7|17|8|@]|9|@]|A|$E|F]]|$1|W|3|-4|5|6|7|18|8|@]|9|@]|A|$]]]|X|$]]

You should always check whether a delegate has no targets (its value is null) before firing it.
As said before, one way of doing this is to subscribe with a do-nothing anonymous method which won't be removed.

<pre><code>public event MyDelegate Fire = delegate {};
</code></pre>

However, this is just a hack to avoid NullReferenceExceptions.

Just simply cheking whether a delegate is null before invoking is not threadsafe as an other thread can deregister after the null-check and making it null when invoking.
There is an other solution is to copy the delegate into a temporary variable:

<pre><code>public event MyDelegate Fire;
public void FireEvent(string msg)
{
 MyDelegate temp = Fire;
 if (temp != null)
 temp(msg);
}
</code></pre>

Unfortunately, the JIT compiler may optimize the code, eliminate the temporary variable, and use the original delegate. (as per Juval Lowy - Programming .NET Components)

So to avoid this problem, you could use method which accepts a delegate as parameter:

<pre><code>[MethodImpl(MethodImplOptions.NoInlining)]
public void FireEvent(MyDelegate fire, string msg)
{
 if (fire != null)
 fire(msg);
}
</code></pre>

Note that without the MethodImpl(NoInlining) attribute the JIT compiler could inline the method making it worthless.
Since delegates are immutable this implementation is threadsafe.
You could use this method as:

<pre><code>FireEvent(Fire,"Hello 3");
</code></pre>

In a code review, I stumbled over this (simplified) code fragment to unregister an event handler:

<pre><code> Fire -= new MyDelegate(OnFire);
</code></pre>

I thought that this does not unregister the event handler because it creates a new delegate which had never been registered before. But searching MSDN I found several code samples which use this idiom.

So I started an experiment:

<pre><code>internal class Program
{
 public delegate void MyDelegate(string msg);
 public static event MyDelegate Fire;

 private static void Main(string[] args)
 {
 Fire += new MyDelegate(OnFire);
 Fire += new MyDelegate(OnFire);
 Fire("Hello 1");
 Fire -= new MyDelegate(OnFire);
 Fire("Hello 2");
 Fire -= new MyDelegate(OnFire);
 Fire("Hello 3");
 }

 private static void OnFire(string msg)
 {
 Console.WriteLine("OnFire: {0}", msg);
 }

}
</code></pre>

To my surprise, the following happened:

<ol>
<li><code>Fire("Hello 1");</code> produced two messages, as expected.</li>
<li><code>Fire("Hello 2");</code> produced one message! 
This convinced me that unregistering <code>new</code> delegates works!</li>
<li><code>Fire("Hello 3");</code> threw a <code>NullReferenceException</code>. 
 Debugging the code showed that <code>Fire</code> is <code>null</code> after unregistering the event.</li>
</ol>

I know that for event handlers and delegate, the compiler generates a lot of code behind the scene. But I still don't understand why my reasoning is wrong.

What am I missing?

Additional question: from the fact that <code>Fire</code> is <code>null</code> when there are no events registered, I conclude that everywhere an event is fired, a check against <code>null</code> is required.

How to correctly unregister an event handler

编译器

在一次代码审查中，我偶然发现了这个(简化的)代码片段来注销一个事件处理程序： Fire -= new MyDelegate(OnFire);我认为这不会注销事件处理程序，因为它创建了一个以前从未注册过的新委托。但在搜索MSDN时，我发现了几个使用此习惯用法的代码示例。所以我开始了一个实验：internal class ...

问如何正确注销事件处理程序
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何正确注销事件处理程序EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何正确注销事件处理程序
EN