基础设施 - 同步和异步接口和实现？ [关闭]

Question

在实现库/基础结构时，此API的用户希望同步和异步使用代码，我读到混合同步和异步不是一个好主意（例如，同步实现包括等待异步实现）。

显然，同步和异步实现应该是分开的。

是否有一种优雅的方法来避免代码（或更准确地说是“流”）重复同步和异步实现，这显然会降低到整个调用层次结构？

interface IMyInterface 
{
    void Foo();
    Task FooAsync();
}

class MyImplementation1 : IMyInterface
{
    public void Foo()
    {
        OtherMethod1();
        OtherMethod2();
        OtherMethod3();
        OtherMethod4();
    }

    public async Task FooAsync()
    {
        await OtherMethod1Async();
        await OtherMethod2Async();
        await OtherMethod3Async();
        await OtherMethod4Async();
    }

    private void OtherMethod1() { /* may contain other sync calls */ }
    private void OtherMethod2() { /* may contain other sync calls */ }
    private void OtherMethod3() { /* may contain other sync calls */ }
    private void OtherMethod4() { /* may contain other sync calls */ }  

    private async Task OtherMethod1Async() { /* may contain other async calls */ }
    private async Task OtherMethod2Async() { /* may contain other async calls */ }
    private async Task OtherMethod3Async() { /* may contain other async calls */ }
    private async Task OtherMethod4Async() { /* may contain other async calls */ }      
}

Answer 1

实现库/基础结构时，此API的用户希望同步和异步地使用代码

理想情况下，库中的每个API应该是自然同步的或自然异步的。我建议只暴露最自然的API。即，如果您的库需要执行I / O，它可以选择仅公开异步API。

是否有一种优雅的方法来避免代码（或更准确地说是“流”）重复同步和异步实现，这显然会降低到整个调用层次结构？

我没有找到理想的解决方案。我最接近的是boolean argument hack，你有异步和同步API都转发到一个带有bool sync参数的内部方法。这个内部方法有一个异步签名（返回一个Task / Task<T>），但如果sync是true，它总是返回一个完成的任务。

最终看起来像这样：

interface IMyInterface 
{
  void Foo();
  Task FooAsync();
}

class MyImplementation1 : IMyInterface
{
  public void Foo() => Foo(sync: true).GetAwaiter().GetResult();
  public Task FooAsync() => Foo(sync: false);

  private async Task Foo(bool sync)
  {
    // Pass `sync` along to all methods that can be sync or async.
    await OtherMethod1(sync);
    await OtherMethod2(sync);
    await OtherMethod3(sync);
    await OtherMethod4(sync);
  }

  private async Task OtherMethod1(bool sync)
  {
    // When you have to choose sync/async APIs of other classes, then choose based on `sync`.
    if (sync)
      Thread.Sleep(1000); // synchronous placeholder
    else
      await Task.Delay(1000); // asynchronous placeholder
  }
}

Answer 2

根据您的逻辑，您仍然可以分享一些逻辑。但它有所不同，它应该有所不同。

如果有帮助，您可以使用模板系统（如T4）生成代码。