blocks|key|5240691|text|是，MethodA将被取消订阅。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|5240692|关于第二个问题，我不是100%25确定，但我认为=+this.MethodA在后台转换为一个代理。|5240693|entityMap^0|2|7|0|M|E|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|P|8|@]|D|@]|E|$]]]|I|$]]

Yes, <code>MethodA</code> will be unsubscribed.

About the second question I'm not 100% sure, but I think <code>= this.MethodA</code> converts to a delegate in the background.

blocks|key|903360|text|是的，它会像你想要的那样工作。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|903361|这种比较不是通过引用，而是通过值，这意味着您可以取消订阅不同的委托，只要它指向同一对象上的同一方法。|903362|换句话说，这将工作得很好：|903363|var+delegate1+=+new+ExternalObjectClickEventHandler(MethodA);
var+delegate2+=+new+ExternalObjectClickEventHandler(MethodA);
ExternalObject.Click+%2B=+delegate1;
ExternalObject.Click+-=+delegate2;|code-block|syntax|javascript|903364|匿名方法是不同的，但你不能这样做：|903365|public+MethodB()
{
++++ExternalObject.Click+%2B=+()+=>+{+return+10;+};
}

public+MethodC()
{
++++ExternalObject.Click+-=+()+=>+{+return+10;+};
}|903366|虽然这些方法包含相同的代码，但它们被认为是不同的，因此这将不起作用，也就是说，MethodC不会取消订阅您在MethodB中添加的委托。|offset|length|style|CODE|903367|要解决此问题，您必须在调用之间存储委托，如下所示：|903368|private+ExternalObjectClickEventHandler+_ClickEventHandler;
public+MethodB()
{
++++_ClickEventHandler+=+()+=>+{+return+10;+};
++++ExternalObject.Click+%2B=+_ClickEventHandler;
}

public+MethodC()
{
++++ExternalObject.Click+-=+_ClickEventHandler;
}|903369|但是你展示的代码，将会起作用。|903370|至于你的问题，在幕后发生了什么，当涉及到生成的代码时，以下两行代码是相同的：|903371|ExternalObject.Click+%2B=+MethodA;
ExternalObject.Click+%2B=+new+ExternalObjectClickEventHandler(MethodA);|903372|第二个代码是从第一个代码生成的代码(假设事件的类型如下所示)。|903373|第一个语法(在某些时候)被添加为“语法糖”，由编译器翻译，就好像你已经编写了第二个语法一样。请注意，只有当编译器能够100%25找出正确的类型时，才会发生这种情况。我见过一些情况(我现在不记得了)，你必须使用完全限定的语法，因为编译器不能理解你的意思。特别是，方法重载和泛型在这方面可能会混淆它。|903374|entityMap^0|0|0|0|0|0|0|13|7|1I|7|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1A|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1B|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|1C|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|1D|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|1E|8|@]|9|@]|A|$]]|$1|M|3|N|5|H|7|1F|8|@]|9|@]|A|$I|J]]|$1|O|3|P|5|6|7|1G|8|@$Q|1H|R|1I|S|T]|$Q|1J|R|1K|S|T]]|9|@]|A|$]]|$1|U|3|V|5|6|7|1L|8|@]|9|@]|A|$]]|$1|W|3|X|5|H|7|1M|8|@]|9|@]|A|$I|J]]|$1|Y|3|Z|5|6|7|1N|8|@]|9|@]|A|$]]|$1|10|3|11|5|6|7|1O|8|@]|9|@]|A|$]]|$1|12|3|13|5|H|7|1P|8|@]|9|@]|A|$I|J]]|$1|14|3|15|5|6|7|1Q|8|@]|9|@]|A|$]]|$1|16|3|17|5|6|7|1R|8|@]|9|@]|A|$]]|$1|18|3|-4|5|6|7|1S|8|@]|9|@]|A|$]]]|19|$]]

Yes, it will work like you want it.

The comparison is not by reference, it is by value, which means that you can unsubscribe a different delegate, as long as it points to the same method on the same object.

In other words, this will work just fine:

<pre><code>var delegate1 = new ExternalObjectClickEventHandler(MethodA);
var delegate2 = new ExternalObjectClickEventHandler(MethodA);
ExternalObject.Click += delegate1;
ExternalObject.Click -= delegate2;
</code></pre>

Anonymous methods are different though, you cannot do this:

<pre><code>public MethodB()
{
 ExternalObject.Click += () =&gt; { return 10; };
}

public MethodC()
{
 ExternalObject.Click -= () =&gt; { return 10; };
}
</code></pre>

While the methods contain the same code, they are considered different, and thus this won't work, that is, <code>MethodC</code> will not unsubscribe the delegate you added in <code>MethodB</code>.

To solve this problem, you have to store the delegate between invocations, like this:

<pre><code>private ExternalObjectClickEventHandler _ClickEventHandler;
public MethodB()
{
 _ClickEventHandler = () =&gt; { return 10; };
 ExternalObject.Click += _ClickEventHandler;
}

public MethodC()
{
 ExternalObject.Click -= _ClickEventHandler;
}
</code></pre>

But the code you showed, will work.

As for your question what happens behind the scenes, is that the following two lines of code are identical when it comes to generated code:

<pre><code>ExternalObject.Click += MethodA;
ExternalObject.Click += new ExternalObjectClickEventHandler(MethodA);
</code></pre>

The second code is what is generated from the first (assuming the type of the event is as shown.)

The first syntax was (at some point) added as "syntactic sugar" that gets translated by the compiler as though you had written the second syntax. Note that this only happens if the compiled can figure out the right type 100%. I've seen some cases (which I can't remember right now) where you had to use the fully qualified syntax because the compiler couldn't figure out what you meant. In particular, method overloads and generics can confuse it in this regard.

I'm wondering if I do something like this:

<pre><code>class A
{
 public MethodA()
 {
 }
 public MethodB()
 {
 ExternalObject.Click += this.MethodA;
 }
 public MethodC()
 {
 ExternalObject.Click -= this.MethodA;
 }
}

A a = new A();
a.MethodB();
a.MethodC();
</code></pre>

Is this going to work? By "work" I mean - will MethodA be unsubscribed from ExternalObject.Click event?

And other related questions:

What happens behind the scenes when an instance method is used instead of delegate instance? (like above)

Does this cause implicit creation of a delegate?

How does <code>-=</code> operator perform comparison between delegates - by reference or maybe something more sophisticated happens?

C# events and class methods

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我在想，如果我这样做：class A{    public MethodA()    {    }    public MethodB()    {        ExternalObject.Click += this.MethodA;    }    public MethodC()    {        Ext...

问C#事件和类方法
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C#事件和类方法EN