blocks|key|16871|text|程序化，这不是错误的，它将为您顺利地工作。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|16872|事实上，当在EventSubscriber中，在Event上应该调用哪个方法(Handler)，而没有EventPublisher类的对象时，您需要这样做。|offset|length|style|CODE|16873|如何订阅活动是一个主观的问题，它取决于你的整体流量和舒适度。|16874|但据我所知，subscriber类中的订阅事件使代码更具可读性，也更容易理解|BOLD|16875|要订阅任何类的事件，subscriber类必须具有该类的对象，但在您的示例中没有。|16876|通常，当subscriber类本身持有publisher类的对象时，人们就会采用这种方法来设计体系结构。这种设计在某些流程中有其自身的好处，请参见下面的示例。|16877|public+class+EventPublisher
{
++++public+event+EventHandler+HeavyLogicDone;

++++public+void+ExposedMethod(string+subScriberSpecificData)
++++{
++++++++Thread+logicCaller+=+new+Thread(()+=>+HeavyLogic(subScriberSpecificData));
++++++++logicCaller.Start();
++++}

++++private+void+HeavyLogic(string+subScriberSpecificData)
++++{
++++++++//logic+which+may+take+time
++++++++if+(HeavyLogicDone+!=+null)
++++++++++++HeavyLogicDone(this,+new+EventArgsClass(subScriberSpecificData));
++++}
}|code-block|syntax|javascript|16878|这里的EventPublisher类有一个公开的功能，应该由EventSubscriber调用，但是由于这个方法可能需要一些时间，所以它是用线程编写的。|16879|现在的问题是，由于它在线程中，此方法的调用将在启动线程后不久返回，订阅者无法启动依赖于此方法的结果的功能，它必须等待。因此，为了通知订阅者任务已经完成，有一个事件。|16880|public+class+EventSubscriber
{
++++string+currentData+=+"";
++++public+EventSubscriber(EventPublisher+eventPublisher,+string+data)
++++{
++++++++currentData+=+data;
++++++++eventPublisher.HeavyLogicDone+%2B=+eventPublisher_HeavyLogicDone;
++++++++eventPublisher.ExposedMethod(currentData);
++++++++//Contineous+without+waiting+for+heavy+logic+to+compelete
++++}

++++void+eventPublisher_HeavyLogicDone(object+sender,+EventArgs+e)
++++{
++++++++if(((EventArgsData)e).subScriberSpecificData+==+currentData)
++++++++{
+++++++++++//Do+further+task+which+is+dependant+to+result+of+logic
+++++++++++//if+now+subscriber+doesn't+need+to+listen+this+event+anymore
+++++++++++((EventPublisher)sender).HeavyLogicDone+-=+eventPublisher_HeavyLogicDone;
++++++++}
++++}
}|16881|正如你所看到的，什么时候订阅事件，什么时候取消订阅，订阅者现在拥有所有的控制权。|16882|16883|但是，如果你这样做的话。|16884|static+void+Main(string[]+args)
{
++++EventSubscriber+subscriber1+=+new+EventSubscriber("sub1");
++++EventSubscriber+subscriber2+=+new+EventSubscriber("sub2");
++++EventPublisher+pub+=+new+EventPublisher();
++++pub.HeavyLogicDone+%2B=+subscriber1.eventPublisher_HeavyLogicDone;
++++pub.HeavyLogicDone+%2B=+subscriber2.eventPublisher_HeavyLogicDone;
++++pub.ExposedMethod("sub1");
++++pub.ExposedMethod("sub2");
}|16885|第一个问题:正如您所看到的，每次创建Subscriber的实例时，都必须显式编写它的subscription和对当前subscriber的publisher方法的调用。这是耦合的代码，您每次都需要这样做。|16886|和订阅者类|16887|public+class+EventSubscriber
{
++++string+currentData+=+"";
++++public+EventSubscriber(string+data)
++++{
++++++++currentData+=+data;
++++}
++++public+void+eventPublisher_HeavyLogicDone(object+sender,+EventArgs+e)
++++{
++++++++if(((EventArgsData)e).subScriberSpecificData+==+currentData)
++++++++{
+++++++++++//Do+further+task+which+is+dependant+to+result+of+logic

+++++++++++//if+now+subscriber+doesn't+need+to+listen+this+event+anymore
+++++++++++((EventPublisher)sender).HeavyLogicDone+-=+eventPublisher_HeavyLogicDone;
++++++++}
++++}
}|16888|第二个问题:由于订阅不受subscriber类的控制，而取消订阅只能通过subscriber类来完成。代码理解起来会有点混乱。|16889|entityMap^0|0|6|F|O|5|13|7|1F|E|0|0|0|12|0|0|0|0|3|E|U|F|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1I|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1J|8|@$D|1K|E|1L|F|G]|$D|1M|E|1N|F|G]|$D|1O|E|1P|F|G]|$D|1Q|E|1R|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|1S|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|1T|8|@$D|1U|E|1V|F|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|1W|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|1X|8|@]|9|@]|A|$]]|$1|Q|3|R|5|S|7|1Y|8|@]|9|@]|A|$T|U]]|$1|V|3|W|5|6|7|1Z|8|@$D|20|E|21|F|G]|$D|22|E|23|F|G]]|9|@]|A|$]]|$1|X|3|Y|5|6|7|24|8|@]|9|@]|A|$]]|$1|Z|3|10|5|S|7|25|8|@]|9|@]|A|$T|U]]|$1|11|3|12|5|6|7|26|8|@]|9|@]|A|$]]|$1|13|3|-4|5|6|7|27|8|@]|9|@]|A|$]]|$1|14|3|15|5|6|7|28|8|@]|9|@]|A|$]]|$1|16|3|17|5|S|7|29|8|@]|9|@]|A|$T|U]]|$1|18|3|19|5|6|7|2A|8|@]|9|@]|A|$]]|$1|1A|3|1B|5|6|7|2B|8|@]|9|@]|A|$]]|$1|1C|3|1D|5|S|7|2C|8|@]|9|@]|A|$T|U]]|$1|1E|3|1F|5|6|7|2D|8|@]|9|@]|A|$]]|$1|1G|3|-4|5|6|7|2E|8|@]|9|@]|A|$]]]|1H|$]]

Programmatic, it is not wrong and will work smooth for you. 

In fact you need to do this in the case where in <code>EventSubscriber</code> of which method 
 (<code>Handler</code>)should be called on <code>Event</code> , doesn't have object of <code>EventPublisher</code> class.

How to subscribe events is subjective matter, it depends on your over all flow and comfort.

But According to me, subscribing event in side of subscriber class make code more readable and easy to understand

you see to subscribe an event of any class, subscriber class must have an object of that class, but here in your example it doesn't have.

Generally people design architecture in such method when subscriber class itself hold the object of publisher class. This design has its own benefits in some flow, see below example,

<pre><code>public class EventPublisher
{
 public event EventHandler HeavyLogicDone;

 public void ExposedMethod(string subScriberSpecificData)
 {
 Thread logicCaller = new Thread(() =&gt; HeavyLogic(subScriberSpecificData));
 logicCaller.Start();
 }

 private void HeavyLogic(string subScriberSpecificData)
 {
 //logic which may take time
 if (HeavyLogicDone != null)
 HeavyLogicDone(this, new EventArgsClass(subScriberSpecificData));
 }
}
</code></pre>

here <code>EventPublisher</code> class has a publicly exposed functionality, which should be called by <code>EventSubscriber</code> , but as this method may take time, it is being written in thread. 

Now problem, as it is in thread, call of this method will return soon after starting the thread, subscriber can not start its functionality which is dependent on this method's result, it must wait. So to notify subscriber that task has been done, there is an event.

<pre><code>public class EventSubscriber
{
 string currentData = "";
 public EventSubscriber(EventPublisher eventPublisher, string data)
 {
 currentData = data;
 eventPublisher.HeavyLogicDone += eventPublisher_HeavyLogicDone;
 eventPublisher.ExposedMethod(currentData);
 //Contineous without waiting for heavy logic to compelete
 }

 void eventPublisher_HeavyLogicDone(object sender, EventArgs e)
 {
 if(((EventArgsData)e).subScriberSpecificData == currentData)
 {
 //Do further task which is dependant to result of logic
 //if now subscriber doesn't need to listen this event anymore
 ((EventPublisher)sender).HeavyLogicDone -= eventPublisher_HeavyLogicDone;
 }
 }
}
</code></pre>

As you can seen when to subscribe an event and when to unsubscribe it, subscriber has all control now. 

<hr>

But, if you would be doing like this.

<pre><code>static void Main(string[] args)
{
 EventSubscriber subscriber1 = new EventSubscriber("sub1");
 EventSubscriber subscriber2 = new EventSubscriber("sub2");
 EventPublisher pub = new EventPublisher();
 pub.HeavyLogicDone += subscriber1.eventPublisher_HeavyLogicDone;
 pub.HeavyLogicDone += subscriber2.eventPublisher_HeavyLogicDone;
 pub.ExposedMethod("sub1");
 pub.ExposedMethod("sub2");
}
</code></pre>

First problem : As you can see, every time you are creating an instance of Subscriber, you have to explicitly write it's subscription and calling of publisher's method for current subscriber. that is coupled code, and you need to keep doing this every time.

and subscriber class

<pre><code>public class EventSubscriber
{
 string currentData = "";
 public EventSubscriber(string data)
 {
 currentData = data;
 }
 public void eventPublisher_HeavyLogicDone(object sender, EventArgs e)
 {
 if(((EventArgsData)e).subScriberSpecificData == currentData)
 {
 //Do further task which is dependant to result of logic

 //if now subscriber doesn't need to listen this event anymore
 ((EventPublisher)sender).HeavyLogicDone -= eventPublisher_HeavyLogicDone;
 }
 }
}
</code></pre>

Second problem : as subscription is not in control of subscriber class, and unsubscribing can be done only withing subscriber class. Code will be little mess to understand.

Should the event subscriber always register the event handler, or is it ok for another class to do it?

Example:

<pre><code>class EventPublisher {

 public event EventHandler Event;
}

class EventSubscriber {

 public void Handler(object sender, EventArgs e) { }
}

class Glue {

 private EventPublisher _publisher = new EventPublisher();

 private EventSubscriber _subscriber = new EventSubscriber();


 public Glue() {
 _publisher.Event += _subscriber.Handler;
 }
}
</code></pre>

Is it bad practice for a class to register an event handler for another class?

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

事件订阅者是否应该始终注册事件处理程序，或者其他类是否可以这样做？示例：class EventPublisher {    public event EventHandler Event;}class EventSubscriber {    public void Handler(object sender, Eve...

一个类为另一个类注册事件处理程序是不是一种糟糕的做法？-腾讯云开发者社区-腾讯云

问一个类为另一个类注册事件处理程序是不是一种糟糕的做法？
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问一个类为另一个类注册事件处理程序是不是一种糟糕的做法？EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问一个类为另一个类注册事件处理程序是不是一种糟糕的做法？
EN