使用异步等待实现具有同步和异步API的库以实现相同的功能

Question

我有一些关于如何在库中提供相同功能的同步和异步实现的问题.我先问他们然后提供下面的示例代码(实际上相当多,但事实上它很简单).

1. 有没有办法避免违反DRY原则？考虑的实现JsonStreamReader.Read,JsonStreamWriter.Write,JsonStreamWriter.Flush,ProtocolMessenger.Send,ProtocolMessenger.Receive和他们的异步版本.

2. 在对同一方法的同步和异步版本进行单元测试时,是否有办法避免违反DRY原则？我正在使用NUnit,虽然我猜所有框架在这方面应该是相同的.

3. 应该如何实施的方法返回Task或Task<Something>考虑Take 1和Take 2变体ComplexClass.Send和ComplexClass.Receive？哪一个是正确的,为什么？

4. 考虑到不知道库将在何处使用(控制台应用程序,Windows窗体,WPF,ASP.NET),总是在库中包含.ConfigureAwait(false)后是否正确await？

以下是我在第一个问题中提到的代码.

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种不同的(可能是相似的,可能不是)实现.您可以尝试查找重复的部分并使用基类(或实用程序类)重用它们,但实现方式大多不同.

在许多情况下,人们选择只提供一个版本的API,无论是否异步.例如,用于YouTube API v3的.Net客户端库完全async可以完成.如果你能负担得起(很多人不能)那将是我的建议.

关于您的具体问题:

1. 不是真的,除了找到相似的部分并将它们抽象掉之外.
2. 不是真的,同步方法需要在同步方面进行测试,而async那些在async上下文.
3. Take 1 (即直接返回任务)最好有两种方式:
   • 它缺乏创建整个不需要的async状态机的开销,这增加了非常轻微的性能提升.
   • ConfigureAwait在这种情况下,只影响它之后的代码,在这种情况下,它根本不会.它是否使用它不会影响调用者的代码ConfigureAwait.
4. 肯定是(最后,积极性).默认情况下,async库中的代码应该使用ConfigureAwait(false),并且只有在特定需要时才删除它.

Answer 2

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

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

如果您处于这种情况，我建议您使用布尔参数 hack来最小化重复代码的数量。同步方法上的异步包装器和异步方法上的同步包装器都是反模式。