C# 在桥接（聚合）类C之间推送事件#

我有一个类似于bellow的类层次结构：

A类
{
事件evA
运行（）{
evA.Invoke（）
}
}
B类
{
事件执行副总裁
运行（）{
evB.Invoke（）
}
}
C类
{
哪怕是一个/？
事件B/？
事件C
A A；
B B；
C（A，B）
{
}
无效运行（）
{
a、 Run（）；
b、 Run（）；
}
}
D类
{
事件evD
C C；
D（C）
{
///在这节课上，我想对事件A、B、C进行总结
}
运行（）
}

类A有自己的事件，与类B相同，并且都有不同的参数。类C使用类A和类B作为依赖项

然后类C在类D中作为依赖项使用，并运行其方法，其原因是所有类A、B、C、D都会引发它们自己的事件

将所有这些事件（evA、evB、evC）归为D类的最佳方法是什么：

---

​ 我应该在C类中声明事件A和B并转发此事件，还是有更好的方法来完成此任务？

类似的方法可以工作，不需要额外的事件

class Program
{
    static void Main(string[] args)
    {
        var a = new A();
        var b = new B();
        var c = new C(a, b);
        var d = new D(c);

        d.Run();
        Console.ReadKey();

    }
}
class A
{
    internal event EventHandler<ArgA> eventA;

    internal void Run()
    {
        eventA?.Invoke(this, new ArgA());
    }
}

class B
{
    internal event EventHandler<ArgB> eventB;

    internal void Run()
    {
        eventB?.Invoke(this, new ArgB());
    }
}

class C
{

    internal event EventHandler<ArgC> eventC;

    internal A A { get; set; }
    internal B B { get; set; }

    internal C(A a, B b)
    {
        A = a;
        B = b;
    }

    internal void Run()
    {
        A.Run();
        B.Run();
    }

}

class D
{
    internal event EventHandler<ArgD> eventD;

    internal C C { get; set; }
    internal D(C c)
    {
        C = c;
    }

    internal void Run()
    {
        C.A.eventA += A_eventA;
        C.B.eventB += B_eventB;
        C.Run();
    }

    private void B_eventB(object sender, ArgB e)
    {
        Console.WriteLine("B was triggered");
    }

    private void A_eventA(object sender, ArgA e)
    {
        Console.WriteLine("A was triggered");
    }
}

类程序
{
静态void Main（字符串[]参数）
{
var a=新的a（）；
var b=新的b（）；
var c=新的c（a，b）；
var d=新的d（c）；
d、 Run（）；
Console.ReadKey（）；
}
}
甲级
{
内部事件处理程序eventA；
内部无效运行（）
{
eventA？.Invoke（这个，新的ArgA（））；
}
}
B类
{
内部事件处理程序eventB；
内部无效运行（）
{
eventB？.Invoke（这个，新的ArgB（））；
}
}
C类
{
内部事件处理程序eventC；
内部A{get；set；}
内部B{get；set；}
内部C（A，B）
{
A=A；
B=B；
}
内部无效运行（）
{
A.运行（）；
B.运行（）；
}
}
D类
{
内部事件处理程序eventD；
内部C{get；set；}
内部D（C）
{
C=C；
}
内部无效运行（）
{
C.A.eventA+=A_eventA；
C.B.eventB+=B_eventB；
C.运行（）；
}
私有void B_eventB（对象发送方，ArgB e）
{
控制台写入线（“B被触发”）；
}
私有void A_eventA（对象发送方，ArgA e）
{
Console.WriteLine（“A被触发”）；
}
}

为什么不订阅D类的活动？c、 a.evA+=HandleA这样您就不需要在类c上声明额外的事件