同步/异步接口实现合并方案及相关技术疑问

1. GetAwaiter().GetResult() 替代 .Result 是否改变逻辑？ #

会有异常处理逻辑的明确差异：

• 当内部方法同步执行完成（无异步操作）且抛出异常时，.Result会把原始异常包装在AggregateException中抛出；而GetAwaiter().GetResult()会直接抛出原始异常，和普通同步方法的异常行为完全一致。
• 若返回的Task已处于完成状态（你的场景中runSynchronously=true时，async方法无await操作，会同步执行并返回已完成Task），两者的阻塞行为没有区别——都不会阻塞，直接获取结果或抛出异常。

所以如果你的同步方法原本预期直接抛出原始异常，用GetAwaiter().GetResult()更贴合原有逻辑；用.Result会改变异常的包装形式，这是一个不可忽视的逻辑变化。

2. 这种实现是否消除了“同步调用异步方法”的常见顾虑？ #

不能完全消除，仅避免了部分核心问题：

• 避免了死锁：当runSynchronously=true时，内部async方法没有await操作，不会捕获当前线程的SynchronizationContext（比如UI线程上下文），也就不存在await后试图回到被阻塞线程导致死锁的情况。
• 避免了异步调度开销：无await的async方法会同步执行，不会触发线程池调度或上下文切换。
• 仍存在的问题：
  • async方法会生成状态机，带来微小但不可忽略的额外性能开销；
  • 异常处理的差异（如上述.Result和GetAwaiter().GetResult()的区别）；
  • 布尔参数的分支会增加代码复杂度，降低可读性，后续维护容易出错（比如你代码中同步方法传了false，实际应该传true才会走同步路径，这就是潜在的bug）。

3. 合并同步/异步方法的常用模式 #

（1）拆分公共逻辑到独立方法 #

把前后无差异的代码拆成同步辅助方法，同步和异步方法各自处理中间的同步/异步调用：

public class MyImplementation : IDoSomething {
    public async Task DoSomethingAsync(object input) {
        PreProcess(input);
        var somethingINeed = await GetSomethingAsync(input, lol);
        PostProcess(input, somethingINeed);
    }

    public void DoSomething(object input) {
        PreProcess(input);
        var somethingINeed = GetSomething(input, lol);
        PostProcess(input, somethingINeed);
    }

    private void PreProcess(object input) {
        // 十几行公共前置逻辑
    }

    private void PostProcess(object input, object somethingINeed) {
        // 十几行公共后置逻辑
    }
}

优点：无额外状态机开销，代码清晰，分支逻辑完全消除；缺点：存在少量重复代码（调用Pre/Post的两行），但对于30行的方法来说，这种重复完全可接受。

（2）抽象依赖接口 #

把需要同步/异步调用的操作抽象成接口，让公共逻辑通过委托或接口方法复用：

public interface ISomethingProvider {
    object GetSomething(object input, object lol);
    Task<object> GetSomethingAsync(object input, object lol);
}

public class MyImplementation : IDoSomething {
    private readonly ISomethingProvider _provider;

    public MyImplementation(ISomethingProvider provider) {
        _provider = provider;
    }

    public async Task DoSomethingAsync(object input) {
        await ProcessCore(input, _provider.GetSomethingAsync);
    }

    public void DoSomething(object input) {
        ProcessCore(input, (i, l) => Task.FromResult(_provider.GetSomething(i, l)))
            .GetAwaiter().GetResult();
    }

    private async Task ProcessCore(object input, Func<object, object, Task<object>> getSomethingFunc) {
        // 十几行公共前置逻辑
        var somethingINeed = await getSomethingFunc(input, lol);
        // 十几行公共后置逻辑
    }
}

优点：公共逻辑完全复用，依赖更灵活，便于单元测试；缺点：需要额外定义接口，适合复杂度较高的场景。

（3）异步优先模式（仅适合CPU密集场景） #

如果操作是CPU密集型，可以优先实现异步方法，同步方法通过Task.Run包装调用：

public class MyImplementation : IDoSomething {
    public async Task DoSomethingAsync(object input) {
        // 公共逻辑 + await GetSomethingAsync(...)
    }

    public void DoSomething(object input) {
        Task.Run(() => DoSomethingAsync(input)).GetAwaiter().GetResult();
    }
}

注意：这种方式会把同步调用放到线程池线程执行，会浪费线程资源，绝对不适合IO绑定操作，仅适合CPU密集场景。

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