我正在努力将一个库转换为使用依赖注入(inject)。我遇到过需要重构的这个(简化的)代码示例:
public class MessageQueueManager {
public static readonly MessageQueueManager Instance =
new MessageQueueManager();
private readonly MessageQueue _highPriority;
private readonly MessageQueue _lowPriority;
private MessageQueueManager() {
_highPriority = new MessageQueue(1);
_lowPriority = new MessageQueue(2);
}
}
public class MessageQueue {
private int _priority;
public MessageQueue(int priority) => _priority = priority;
public void QueueMessage(Message msg) {
_queue.Add(msg);
MessageQueueManager.Instance.NotifyMessageQueued(this);
}
}
public class Message {
public Message(string text, Action onDismiss) { ... }
private void Dismiss() {
_onDismiss();
MessageQueueManager.Instance.MessageDismissed(this);
}
}
//to display a message:
MyQueue.QueueMessage(new Message(...));
我的第一次尝试是这颗 Shiny 的 gem :
public class MessageQueueManager : IMessageQueueManager {
private readonly IMessageQueue _highPriority;
private readonly IMessageQueue _lowPriority;
private MessageQueueManager(
Func<IMessageQueueManager, int,
/* several other dependencies*/
IMessageQueue> queueConstructor,
/*several other dependencies*/)
{
_highPriority = queueConstructor(this, 1/*, several other deps*/);
_lowPriority = queueConstructor(this, 2/*, several other deps*/);
}
}
public class MessageQueue : IMessageQueue {
private readonly IMessageQueueManager _owner;
private readonly int _priority;
public MessageQueue(
IMessageQueueManager owner, int priority,
/*several other dependencies*/)
{
_owner = owner;
_priority = priority;
/*deal with several other dependencies*/
}
public void QueueMessage(IMessage msg)
{
_msg.Manager = _owner;
_queue.Add(msg);
_owner.NotifyMessageQueued(this);
}
}
public class Message : IMessage {
public IMessageQueueManager Manager {get; set;}
public Message(string text, Action onDismiss)
{
//...
}
private void Dismiss() {
_onDismiss();
Manager.MessageDismissed(this);
}
}
MyQueue.QueueMessage(new Message(...));
所以……我不喜欢。
另请注意,其他地方已经构建了自己的 MessageQueue
,它们不直接归管理器所有,但仍与同一系统交互。 MessageQueueManager
提供的两个只是大多数地方将使用的默认值。
有没有更简洁的方法来处理这个问题?让 Message 的构造函数接受 MessageQueueManager 是否更有意义?是否每个构造新消息的地方都需要注入(inject)该管理器? (这是一个充满消息的大图书馆,我试图一次做几件,所以这将是一项艰巨的任务,尽管最终必须完成......)
我还处于早期阶段。我计划最终使用一些 DI 库,虽然我还没有决定使用哪个库,而且我不知道在这种情况下它对具体创建新消息有什么帮助。如果它是一些包罗万象的对象,我可以传递它来为我创建消息和获取管理器,那将会很有帮助,但显然这不是“正确的依赖注入(inject)”,更像是一个“服务定位器”,这显然是一件坏事,我猜?
最佳答案
您必须进行一些调整:
1。你需要 IMessage
吗?
如果你有多个队列消息的实现,那么当然可以,否则,如果消息只包含数据,也许这个接口(interface)可以省略。
2。将 MessageQueueManager
与 Message
解耦
如果 Message
使用 MessageQueueManager
,那么通过依赖注入(inject),您必须在创建消息时开始将 MessageQueueManager
传递给消息。假设您可能有很多地方在不知道队列管理器的情况下创建消息,将 MessageQueueManager
作为参数传递可能是一个巨大的变化。你可能想避免这样做。
让我们假设当一条消息可以被关闭时,它应该已经在一个或多个队列中。在这种情况下,我们可以将关闭操作委托(delegate)给添加消息的队列,并且消息队列知道它们的管理器是有意义的。
所以你需要这样的东西:
public class Message : IMessage
{
public Message(string text, Action onDismiss) { }
// This is set by MessageQueue when the message is being added to the queue
internal IMessageQueue Queue { get; set; }
public void Dismiss()
{
//_onDismiss();
if (Queue == null)
{
throw new InvalidOperationException("Message not queued.");
}
Queue.DismissMessage(this);
}
}
3。 MessageQueue
创建
MessageQueue
创建需要集中。这样一来,一旦队列被实例化,您就可以为其设置 MessageQueueManager
,以便队列可以处理 NotifyMessageQueued
和 MessageDismissed
。
就像您已经尝试过的那样(注入(inject) queueConstructor
),您需要按照其他人的说法,
Use a factory.
根据 Dependency inversion principle,这里的工厂应该是您自己的工厂 .您应该避免在 Autofac 中使用任何 DI 框架特定工厂,例如 ILifetimeScope
。这是因为依赖注入(inject)是一种工具,应该是可选的。您需要依赖倒置而不是依赖注入(inject)。所以我建议您不要将您的类型绑定(bind)到一个 DI 框架。
public interface IMessageQueueFactory
{
// Those are shotcuts to CreatePriority(N)
IMessageQueue CreateLowPriority();
IMessageQueue CreateHighPriority();
IMessageQueue CreatePriority(int priority);
}
// Forgive the verbosal name here. It indicates the factory creates instance of MessageQueue.
public class MessageQueueMessageQueueFactory : IMessageQueueFactory
{
private Lazy<IMessageQueueManager> _manager;
// The reason for using Lazy<T> here is becuase we have circular dependency in this design:
// MessageQueueManager -> MessageQueueMessageQueueFactory -> MessageQueueManager
// No all DI framework can handle this, so we have to defer resolving manager instance
// Also because queue manager is a singleton instance in the container, so deferred resolving
// doesn't cause much pain such as scoping issues.
public MessageQueueMessageQueueFactory(Lazy<IMessageQueueManager> manager)
{
_manager = manager;
}
public IMessageQueue CreateHighPriority()
{
return CreatePriority(1);
}
public IMessageQueue CreateLowPriority()
{
return CreatePriority(2);
}
public IMessageQueue CreatePriority(int priority)
{
return new MessageQueue(priority, _manager);
}
}
如果您需要将特定于框架的工厂注入(inject)到 MessageQueueMessageQueueFactory
中,这很好,因为它应该是一个适配器,将您自己的类型创建转换为 DI 类型解析。
MessageQueue
现在看起来像:
public class MessageQueue : IMessageQueue
{
private int _priority;
private Lazy<IMessageQueueManager> _manager;
// Use internal constructor to encourage using factory to instantiate message queue.
internal MessageQueue(int priority, Lazy<IMessageQueueManager> manager)
{
_priority = priority;
_manager = manager;
}
public void QueueMessage(IMessage msg)
{
_queue.Add(msg);
((Message)msg).Queue = this;
_manager.Value.NotifyMessageQueued(this);
}
public void DismissMessage(IMessage msg)
{
// So we have a type cast here. Depends on your message queue implemenation,
// this is ok or not.
// For example, if this is a RabbitMQ message queue, of course the message
// instance must also be a RabbitMQ message, so cast is fine.
// However, if the message queue is a base class for other message queues, this
// should be avoided.
// And this also goes back to the point: Do you really need an IMessage interface?
if (((Message)msg).Queue != this)
{
throw new InvalidOperationException("Message is not queued by current instance.");
}
_manager.Value.MessageDismissed(this);
}
}
4。在 MessageQueueManager
中创建消息队列
现在我们有了实例化消息队列的工厂,我们可以在 MessageQueueManager
的构造函数中使用它:
public class MessageQueueManager : IMessageQueueManager
{
private readonly IMessageQueue _highPriority;
private readonly IMessageQueue _lowPriority;
public MessageQueueManager(IMessageQueueFactory queueFactory)
{
_highPriority = queueFactory.CreateHighPriority();
_lowPriority = queueFactory.CreateLowPriority();
}
}
注意因为我们要使用依赖注入(inject),而MessageQueueManager
现在使用了IMessageQueueFactory
,所以我们需要将它从真正的单例改为DI单例,通过去掉Instance
属性并将类型注册为单例
5。您需要处理队列族吗?
假设您有多个队列实现,您可能不想混淆特定于队列的类型。例如,您不想将 RabbitMQ 消息添加到 MSMQ 队列。如果是这种情况,您可以使用 Abstract factory pattern :
public interface IMessageQueueProvider
{
IMessageQueueManager CreateManager();
IMessageQueueFactory CreateFactory();
IMessage CreateMessage();
}
但是,这有点超出范围。
最后
注册新类型。我以 Microsoft Extensions Dependency Injection 为例:
var services = new ServiceCollection();
services.AddSingleton<IMessageQueueManager, MessageQueueManager>();
services.AddSingleton<IMessageQueueFactory, MessageQueueMessageQueueFactory>();
// Most DI containers now should support Lazy<T>, in case if it is not, you could add
// explicit registration.
services.AddTransient(
provider => new Lazy<IMessageQueueManager>(
() => provider.GetRequiredService<IMessageQueueManager>()));
// This provides a way to resolve low priority queue as IMessageQueue when injected into
// other types.
services.AddTransient(
provider => provider.GetRequiredService<IMessageQueueFactory>().CreateLowPriority());
这里有一些例子:
class Examples
{
public Examples(
// This is the queue manager
IMessageQueueManager manager,
// This is the queue factory for creating queues
IMessageQueueFactory factory,
// This is default queue implemenation, in this case a low priority queue
IMessageQueue queue)
{
// This is queue with arbitrary priority.
var differentPriorityQueue = factory.CreatePriority(3);
// Queue a message and dismiss.
var msg = new Message("Text", () => { });
queue.QueueMessage(msg);
msg.Dismiss();
}
}
关于c# - 如何使用依赖注入(inject)在运行时创建新对象,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/60887416/