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

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. 始终包含 .ConfigureAwait(false) 是否正确？在 await 之后在库中，考虑到不知道库将在哪里使用(控制台应用程序、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);
    }
}

最佳答案

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

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

关于您的具体问题:

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

关于c# - 在实现具有同步和异步 API 的库以实现相同功能时使用 async await，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/27862483/