C#跨类事件绑定最佳实践：如何将EndClass.OnStartEvent绑定到StartClass.StartEvent及相关实现疑问

首先先纠正一个小细节：你的原始代码里StartClass的StartEvent定义不完整，C#事件必须指定委托类型（比如自定义委托或EventHandler），我会在后续示例里补全这个前提。

你的思路是否正确？ #

你的思路是可行的，但有需要注意的细节，同时也有更符合封装原则的替代方案：

• 可行原因：通过MidClass暴露StartClass的事件，能让EndClass不需要直接依赖StartClass就能完成事件绑定，贴合依赖倒置的部分思想。
• 注意事项：不能直接把StartClass的事件字段暴露出来（原代码里StartClass的StartEvent默认是private，MidClass根本访问不到），必须用带add/remove访问器的事件属性来包装，同时要把StartClass的StartEvent改为public（或internal）让MidClass可以访问。

不过这个方式存在小缺点：MidClass相当于把内部依赖StartClass的事件直接对外暴露，破坏了封装性——外部代码可以通过MidClass直接操作StartClass的事件，可能超出MidClass的职责范围。

如何实现事件绑定？ #

我分两种方式给出具体示例：

方式1：你的思路（包装内部事件）

首先定义事件的委托类型（这里用自定义委托更贴合场景，用EventHandler也可以）：

public delegate void StartEventHandler();

修改StartClass，让事件可访问：

class StartClass 
{ 
    // 改为public，让MidClass可以访问
    public event StartEventHandler StartEvent; 

    // 触发事件的标准方法（通常定义为protected virtual，符合开闭原则）
    protected virtual void OnStartEvent()
    {
        StartEvent?.Invoke();
    }

    // 示例：触发事件的业务方法
    public void TriggerStart()
    {
        OnStartEvent();
    }
}

在MidClass里添加事件属性包装StartClass的事件：

class MidClass 
{ 
    private StartClass _startClass; 

    public MidClass(StartClass startClass) 
    { 
        _startClass = startClass; 
    } 

    // 用事件属性包装StartClass的StartEvent
    public event StartEventHandler StartEvent
    {
        add => _startClass.StartEvent += value;
        remove => _startClass.StartEvent -= value;
    }

    // some code
}

最后在EndClass的构造函数里完成绑定：

class EndClass 
{ 
    private MidClass _midClass; 

    public EndClass(MidClass midClass) 
    { 
        _midClass = midClass;
        // 绑定事件
        _midClass.StartEvent += OnStartEvent;
    } 

    // some code
    public void OnStartEvent() 
    { 
        Console.WriteLine("EndClass received StartEvent!");
    }
}

方式2：更优雅的封装方案（事件转发）

如果想让MidClass更好地封装内部逻辑，推荐让MidClass自己定义事件，然后订阅StartClass的事件并转发——这样MidClass可以控制事件的传递，甚至添加自己的处理逻辑，同时不会暴露内部依赖的细节：

修改MidClass如下：

class MidClass 
{ 
    private StartClass _startClass; 

    // MidClass自己的事件
    public event StartEventHandler StartEvent;

    public MidClass(StartClass startClass) 
    { 
        _startClass = startClass;
        // 订阅StartClass的事件，触发自己的事件
        _startClass.StartEvent += ForwardStartEvent;
    } 

    private void ForwardStartEvent()
    {
        // 这里可以添加MidClass自己的处理逻辑
        Console.WriteLine("MidClass is forwarding StartEvent...");
        // 触发自己的事件
        StartEvent?.Invoke();
    }

    // some code
}

EndClass的绑定方式和之前完全一致，但此时EndClass完全不知道StartClass的存在，只依赖MidClass，更符合单一职责和封装原则。

总结 #

• 你的思路是可行的，但要注意用事件属性正确包装内部事件，并且确保StartClass的事件可访问。
• 从代码的可维护性和封装性来看，更推荐事件转发的方式，让MidClass作为事件的中转者，而不是直接暴露内部依赖的事件。

内容的提问来源于stack exchange，提问作者Totone