C#中能否将分部类关联至多个类？重复逻辑复用方案咨询

分部类在这里完全不适用——它的作用是把同一个类的代码拆分到多个文件，本质还是同一个类型。而你的ImplStep1和ImplStep2是两个独立的类，分别继承不同的抽象类，分部类解决不了跨类的逻辑复用问题。

下面是针对你场景的3种实用重构方案：

方案1：提取公共逻辑到辅助类 #

不用修改现有抽象类结构，把重复的逻辑封装成静态辅助方法，让两个实现类直接调用即可。

辅助类代码 #

public static class StepStatusHelper
{
    // 封装公共的Completed逻辑，传入事件实例用于触发
    public static bool ExecuteCompletedLogic(EventHandler stepCompletedEvent)
    {
        // 这里放原本的公共逻辑代码
        // ...

        // 触发StepCompleted事件
        stepCompletedEvent?.Invoke(null, EventArgs.Empty);
        return true;
    }

    // 封装公共的StatusUpdate逻辑
    public static void ExecuteStatusUpdateLogic(EventHandler statusUpdateEvent, string statusMessage)
    {
        // 这里放原本的公共逻辑代码
        // ...

        // 触发StatusUpdate事件
        statusUpdateEvent?.Invoke(null, EventArgs.Empty);
    }
}

实现类调用示例 #

public class ImplStep1 : Step1
{
    public event EventHandler StepCompleted;
    public event EventHandler StatusUpdate;

    private bool Completed()
    {
        return StepStatusHelper.ExecuteCompletedLogic(StepCompleted);
    }

    private void StatusUpdate(string statusMessage)
    {
        StepStatusHelper.ExecuteStatusUpdateLogic(StatusUpdate, statusMessage);
    }

    // 类独有的内容
}

ImplStep2直接复用上述调用逻辑即可。

方案2：用组合模式封装公共逻辑 #

创建一个实现IStepStatus的公共处理类，把所有接口相关的公共逻辑和事件都封装在这里，实现类通过持有该类的实例来复用逻辑。

公共处理类代码 #

public class StepStatusHandler : IStepStatus
{
    public event EventHandler StepCompleted;
    public event EventHandler StatusUpdate;
    public event PropertyChangedEventHandler PropertyChanged;

    public bool Completed()
    {
        // 公共逻辑代码
        // ...
        StepCompleted?.Invoke(null, EventArgs.Empty);
        return true;
    }

    public void UpdateStatus(string statusMessage)
    {
        // 公共逻辑代码
        // ...
        StatusUpdate?.Invoke(null, EventArgs.Empty);
        // 若需要触发INotifyPropertyChanged，逻辑也放在这里
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(...)));
    }
}

实现类委托示例 #

public class ImplStep1 : Step1
{
    private readonly StepStatusHandler _statusHandler = new StepStatusHandler();

    // 把接口事件委托给_statusHandler
    public event EventHandler StepCompleted
    {
        add => _statusHandler.StepCompleted += value;
        remove => _statusHandler.StepCompleted -= value;
    }

    public event EventHandler StatusUpdate
    {
        add => _statusHandler.StatusUpdate += value;
        remove => _statusHandler.StatusUpdate -= value;
    }

    public event PropertyChangedEventHandler PropertyChanged
    {
        add => _statusHandler.PropertyChanged += value;
        remove => _statusHandler.PropertyChanged -= value;
    }

    private bool Completed()
    {
        return _statusHandler.Completed();
    }

    private void StatusUpdate(string statusMessage)
    {
        _statusHandler.UpdateStatus(statusMessage);
    }

    // 类独有的内容
}

这个方案能彻底隔离公共逻辑，后续修改只需要改StepStatusHandler即可。

方案3：调整抽象类继承结构（需修改原有抽象类） #

如果允许修改Step1和Step2的代码，可以让它们继承一个共同的基类，把公共逻辑放在基类中实现。

调整后的抽象类结构 #

// 新增公共基类，实现IStepStatus的公共逻辑
public abstract class BaseStep : IStepStatus
{
    public event EventHandler StepCompleted;
    public event EventHandler StatusUpdate;
    public event PropertyChangedEventHandler PropertyChanged;

    protected bool Completed()
    {
        // 公共逻辑代码
        // ...
        StepCompleted?.Invoke(null, EventArgs.Empty);
        return true;
    }

    protected void UpdateStatus(string statusMessage)
    {
        // 公共逻辑代码
        // ...
        StatusUpdate?.Invoke(null, EventArgs.Empty);
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(...)));
    }
}

// 修改原有抽象类，继承BaseStep
public abstract class Step1 : BaseStep
{
    // 保留Step1独有的方法
}

public abstract class Step2 : BaseStep
{
    // 保留Step2独有的方法
}

简化后的实现类 #

public class ImplStep1 : Step1
{
    private bool Completed()
    {
        return base.Completed(); // 直接调用基类的公共逻辑
    }

    private void StatusUpdate(string statusMessage)
    {
        base.UpdateStatus(statusMessage);
    }

    // 类独有的内容
}

这个方案最简洁，但需要你有权修改Step1和Step2的继承关系。

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