在实现具有同步和异步 API 的库以实现相同功能时使用 async await

Question

我有几个关于如何在库中提供相同功能的同步和异步实现的问题。我先问问他们，然后提供下面的示例代码（其实有点多，其实很简单）。

有没有办法避免违反DRY原则？考虑 JsonStreamReader.Read、JsonStreamWriter.Write、JsonStreamWriter.Flush、ProtocolMessenger.Send、ProtocolMessenger.Receive 及其异步版本的实现。
在对同一方法的同步版本和异步版本进行单元测试时，是否有一种方法可以避免违反 DRY 原则？我正在使用 NUnit，虽然我猜所有框架在这方面应该是相同的。
考虑到 ComplexClass.Send 和 Take 1 和 Take 2 变体，应该如何实现返回 Task 或 Task<Something> 的方法=25=]?哪一个是正确的，为什么？
在库中的 await 之后始终包含 .ConfigureAwait(false) 是否正确，因为不知道库将在何处使用（控制台应用程序，Windows表单，WPF，ASP.NET)?

下面是我在第一个问题中提到的代码。

IWriter 和 JsonStreamWriter:

public interface IWriter
{
    void Write(object obj);
    Task WriteAsync(object obj);
    void Flush();
    Task FlushAsync();
}

public class JsonStreamWriter : IWriter
{
    private readonly Stream _stream;

    public JsonStreamWriter(Stream stream)
    {
        _stream = stream;
    }

    public void Write(object obj)
    {
        string json = JsonConvert.SerializeObject(obj);
        byte[] bytes = Encoding.UTF8.GetBytes(json);
        _stream.Write(bytes, 0, bytes.Length);
    }

    public async Task WriteAsync(object obj)
    {
        string json = JsonConvert.SerializeObject(obj);
        byte[] bytes = Encoding.UTF8.GetBytes(json);
        await _stream.WriteAsync(bytes, 0, bytes.Length).ConfigureAwait(false);
    }

    public void Flush()
    {
        _stream.Flush();
    }

    public async Task FlushAsync()
    {
        await _stream.FlushAsync().ConfigureAwait(false);
    }
}

IReader 和 JsonStreamReader:

public interface IReader
{
    object Read(Type objectType);
    Task<object> ReadAsync(Type objectType);
}

public class JsonStreamReader : IReader
{
    private readonly Stream _stream;

    public JsonStreamReader(Stream stream)
    {
        _stream = stream;
    }

    public object Read(Type objectType)
    {
        byte[] bytes = new byte[1024];
        int bytesRead = _stream.Read(bytes, 0, bytes.Length);
        string json = Encoding.UTF8.GetString(bytes, 0, bytesRead);
        object obj = JsonConvert.DeserializeObject(json, objectType);
        return obj;
    }

    public async Task<object> ReadAsync(Type objectType)
    {
        byte[] bytes = new byte[1024];
        int bytesRead = await _stream.ReadAsync(bytes, 0, bytes.Length).ConfigureAwait(false);
        string json = Encoding.UTF8.GetString(bytes, 0, bytesRead);
        object obj = JsonConvert.DeserializeObject(json, objectType);
        return obj;
    }
}

IMessenger 和 ProtocolMessenger:

public interface IMessenger
{
    void Send(object message);
    Task SendAsync(object message);
    object Receive();
    Task<object> ReceiveAsync();
}

public interface IMessageDescriptor
{
    string GetMessageName(Type messageType);
    Type GetMessageType(string messageName);
}

public class Header
{
    public string MessageName { get; set; }
}

public class ProtocolMessenger : IMessenger
{
    private readonly IMessageDescriptor _messageDescriptor;
    private readonly IWriter _writer;
    private readonly IReader _reader;

    public ProtocolMessenger(IMessageDescriptor messageDescriptor, IWriter writer, IReader reader)
    {
        _messageDescriptor = messageDescriptor;
        _writer = writer;
        _reader = reader;
    }

    public void Send(object message)
    {
        Header header = new Header();
        header.MessageName = _messageDescriptor.GetMessageName(message.GetType());

        _writer.Write(header);
        _writer.Write(message);
        _writer.Flush();
    }

    public async Task SendAsync(object message)
    {
        Header header = new Header();
        header.MessageName = _messageDescriptor.GetMessageName(message.GetType());

        await _writer.WriteAsync(header).ConfigureAwait(false);
        await _writer.WriteAsync(message).ConfigureAwait(false);
        await _writer.FlushAsync().ConfigureAwait(false);
    }

    public object Receive()
    {
        Header header = (Header)_reader.Read(typeof(Header));
        Type messageType = _messageDescriptor.GetMessageType(header.MessageName);
        object message = _reader.Read(messageType);
        return message;
    }

    public async Task<object> ReceiveAsync()
    {
        Header header = (Header)await _reader.ReadAsync(typeof(Header)).ConfigureAwait(false);
        Type messageType = _messageDescriptor.GetMessageType(header.MessageName);
        object message = await _reader.ReadAsync(messageType).ConfigureAwait(false);
        return message;
    }
}

ComplexClass:

public interface ISomeOtherInterface
{
    void DoSomething();
}

public class ComplexClass : IMessenger, ISomeOtherInterface
{
    private readonly IMessenger _messenger;
    private readonly ISomeOtherInterface _someOtherInterface;

    public ComplexClass(IMessenger messenger, ISomeOtherInterface someOtherInterface)
    {
        _messenger = messenger;
        _someOtherInterface = someOtherInterface;
    }

    public void DoSomething()
    {
        _someOtherInterface.DoSomething();
    }

    public void Send(object message)
    {
        _messenger.Send(message);
    }

    // Take 1
    public Task SendAsync(object message)
    {
        return _messenger.SendAsync(message);
    }

    // Take 2
    public async Task SendAsync(object message)
    {
        await _messenger.SendAsync(message).ConfigureAwait(false);
    }

    public object Receive()
    {
        return _messenger.Receive();
    }

    // Take 1
    public Task<object> ReceiveAsync()
    {
        return _messenger.ReceiveAsync();
    }

    // Take 2
    public async Task<object> ReceiveAsync()
    {
        return await _messenger.ReceiveAsync().ConfigureAwait(false);
    }
}

Answer 1

这里的一般答案是，使同一功能的 真正 async 和同步版本需要 2 不同（可能相似，可能不相同） ) 实现。您可以尝试找到重复的部分并使用基础 class（或实用程序 class）重用它们，但实现方式大多不同。

在很多情况下，人们选择只提供 API 的一个版本，无论是否异步。例如，.Net client library for YouTube API v3 完全是 async。如果您负担得起（很多人负担不起），那将是我的建议。

关于您的具体问题：

不是真的，除了找到相似的部分并将它们抽象出来。
不一定，同步方法需要在同步上下文中进行测试，而 async 方法需要在 async 上下文中进行测试。
Take 1（即直接返回任务）有两种方式更可取：
- 它没有创建整个不需要的 async 状态机的开销，这增加了 非常轻微的 性能提升。
- ConfigureAwait 在这种情况下只影响它后面的代码，在这种情况下根本就是 none。是否使用ConfigureAwait不影响调用者的代码。
绝对是（最后，积极性）。 async 库中的代码应默认使用 ConfigureAwait(false)，只有在有特定需要时才将其删除。

Answer 2

一般来说，API 要么是异步的，要么是同步的。例如，如果您的实现包括 I/O，它应该是异步的。

也就是说，在某些情况下您确实希望同时拥有同步和异步 API。例如，如果工作自然是异步的，但需要保留同步 API 以实现向后兼容性。

如果您遇到这种情况，我建议您使用 boolean argument hack to minimize the amount of duplicated code. Asynchronous wrappers over synchronous methods and synchronous wrappers over asynchronous methods 都是反模式。

在实现具有同步和异步 API 的库以实现相同功能时使用 async await

Using async await when implementing a library with both synchronous and asynchronous API for the same functionality

.net

c#

dry

async-await

关于您的具体问题：