如何合并仅同步/异步方法差异的类，消除重复且不暴露冗余方法？

方案1：显式接口分离同步/异步逻辑 #

定义两个独立接口分别对应同步和异步操作，基类通过显式接口实现隐藏不需要的方法，派生类只需实现对应接口的逻辑，用户使用时只会看到对应类型的方法：

// 基类所在程序集
public interface ISyncEvaluator
{
    object? Evaluate();
}

public interface IAsyncEvaluator
{
    Task<object?> EvaluateAsync();
}

public abstract class A : ISyncEvaluator, IAsyncEvaluator
{
    // 显式实现接口，默认抛出未实现异常（或编写通用基础逻辑）
    object? ISyncEvaluator.Evaluate()
    {
        throw new NotImplementedException("请在同步派生类中实现此方法");
    }

    Task<object?> IAsyncEvaluator.EvaluateAsync()
    {
        throw new NotImplementedException("请在异步派生类中实现此方法");
    }

    // 所有通用逻辑放在这里，比如参数校验、结果处理
    protected object? ProcessResult(object? rawResult)
    {
        // 通用处理逻辑示例
        return rawResult;
    }
}

// 同步派生类B所在程序集
public class B : A, ISyncEvaluator
{
    public new object? Evaluate()
    {
        var rawResult = GetSyncData();
        return base.ProcessResult(rawResult);
    }

    private object? GetSyncData()
    {
        // 同步业务逻辑
        return null;
    }
}

// 异步派生类C所在程序集
public class C : A, IAsyncEvaluator
{
    public new async Task<object?> EvaluateAsync()
    {
        var rawResult = await GetAsyncData();
        return base.ProcessResult(rawResult);
    }

    private Task<object?> GetAsyncData()
    {
        // 异步业务逻辑
        return Task.FromResult<object?>(null);
    }
}

方案2：泛型基类+策略模式 #

把同步/异步的差异封装成策略类，基类通过泛型约束限定策略类型，对外只暴露统一的调用入口，用户无需区分同步异步：

// 基类所在程序集
public interface IEvaluationStrategy
{
    Task<object?> ExecuteAsync();
}

// 同步策略：将同步逻辑包装为Task
public class SyncEvaluationStrategy : IEvaluationStrategy
{
    private readonly Func<object?> _syncFunc;

    public SyncEvaluationStrategy(Func<object?> syncFunc)
    {
        _syncFunc = syncFunc;
    }

    public Task<object?> ExecuteAsync()
    {
        return Task.FromResult(_syncFunc());
    }
}

// 异步策略
public class AsyncEvaluationStrategy : IEvaluationStrategy
{
    private readonly Func<Task<object?>> _asyncFunc;

    public AsyncEvaluationStrategy(Func<Task<object?>> asyncFunc)
    {
        _asyncFunc = asyncFunc;
    }

    public Task<object?> ExecuteAsync()
    {
        return _asyncFunc();
    }
}

public abstract class A<T> where T : IEvaluationStrategy
{
    protected readonly T _strategy;

    protected A(T strategy)
    {
        _strategy = strategy;
    }

    // 统一对外暴露异步入口
    public async Task<object?> EvaluateAsync()
    {
        // 通用校验逻辑
        Validate();
        var rawResult = await _strategy.ExecuteAsync();
        // 通用结果处理
        return ProcessResult(rawResult);
    }

    protected void Validate()
    {
        // 通用校验逻辑示例
    }

    protected object? ProcessResult(object? rawResult)
    {
        // 通用处理逻辑示例
        return rawResult;
    }
}

// 同步派生类B所在程序集
public class B : A<SyncEvaluationStrategy>
{
    public B() : base(new SyncEvaluationStrategy(GetSyncData))
    {
    }

    private static object? GetSyncData()
    {
        // 同步业务逻辑
        return null;
    }
}

// 异步派生类C所在程序集
public class C : A<AsyncEvaluationStrategy>
{
    public C() : base(new AsyncEvaluationStrategy(GetAsyncData))
    {
    }

    private static Task<object?> GetAsyncData()
    {
        // 异步业务逻辑
        return Task.FromResult<object?>(null);
    }
}

方案3：基类仅保留受保护核心逻辑，派生类按需暴露方法 #

基类只定义受保护的通用逻辑，派生类根据自身特性公开对应的公共方法，完全避免用户看到冗余方法：

// 基类所在程序集
public abstract class A
{
    // 受保护的同步核心逻辑
    protected object? CoreLogic()
    {
        // 通用核心逻辑示例
        return null;
    }

    // 受保护的异步核心逻辑（如果有独立异步通用逻辑可单独实现）
    protected Task<object?> CoreLogicAsync()
    {
        return Task.FromResult(CoreLogic());
    }
}

// 同步派生类B所在程序集
public class B : A
{
    public object? Evaluate()
    {
        return base.CoreLogic();
    }
}

// 异步派生类C所在程序集
public class C : A
{
    public async Task<object?> EvaluateAsync()
    {
        return await base.CoreLogicAsync();
    }
}

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