关于如何在库中提供相同功能的同步和异步实现,我有几个问题。我会先问他们,然后提供下面的示例代码(实际上很多,但实际上很简单)。
有没有办法避免违反 DRY 原则?考虑
JsonStreamReader.Read
的实现,JsonStreamWriter.Write
,JsonStreamWriter.Flush
,ProtocolMessenger.Send
,ProtocolMessenger.Receive
及其异步版本。在对同一方法的同步和异步版本进行单元测试时,是否有一种方法可以避免违反 DRY 原则?我正在使用 NUnit,尽管我想所有框架在这方面应该都是一样的。
应该如何实现返回
Task
的方法或Task<Something>
考虑到Take 1
和Take 2
ComplexClass.Send
的变体和ComplexClass.Receive
?哪一个是正确的,为什么?始终包含
.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
一路走来。如果您负担得起(很多人负担不起),那将是我的建议。
关于您的具体问题:
- 不是真的,除了找到相似的部分并将它们抽象出来。
- 并非如此,同步方法需要在同步上下文中进行测试,同时
async
async
中的那些上下文。 -
Take 1
(即直接返回任务)有两种方式更可取:- 它没有创建整个不需要的开销
async
添加非常轻微性能提升的状态机。 -
ConfigureAwait
在这种情况下只影响它后面的代码,在这种情况下根本没有。是否使用ConfigureAwait
不影响调用者的代码还是不是。
- 它没有创建整个不需要的开销
- 绝对是(最后,积极性)。
async
库中的代码应使用ConfigureAwait(false)
默认情况下,只有在有特定需要时才将其删除。
关于c# - 在实现具有同步和异步 API 的库以实现相同功能时使用 async await,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/27862483/