c# - 如何使用依赖注入(inject)在运行时创建新对象

Question

我正在努力将一个库转换为使用依赖注入(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)”，更像是一个“服务定位器”，这显然是一件坏事，我猜？

Answer 1

您必须进行一些调整:

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();
    }
}