如何使用依赖注入在运行时创建新对象

Question

我正在将库转换为使用依赖注入。我遇到过这个（简化的）需要重构的代码示例：

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

我的第一次尝试是这颗闪亮的宝石：

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

所以……我不喜欢。

另请注意，其他地方已经构建了自己的MessageQueues，这些 s 不直接归经理所有，但仍与同一系统交互。提供的两个MessageQueueManager只是大多数地方将使用的默认值。

有没有更干净的方法来处理这个问题？在 MessageQueueManager 中使用 Message 的构造函数是否更有意义？是否每个构建新消息的地方都需要注入那个管理器？（这是一个很大的图书馆，到处都是消息，我正在尝试一次做几件，所以这将是一项艰巨的任务，尽管最终必须完成......）

我处于早期阶段。我计划最终使用一些 DI 库，尽管我还没有决定使用哪个库，而且我不知道它在这种情况下如何真正帮助创建新的消息。如果它是一个包罗万象的对象，我可以传递它来为我创建消息和获取管理器，这将是有帮助的，但显然这不是“适当的依赖注入”，而更多的是“服务定位器”，这显然是一件坏事，我猜？

Answer 1

您必须进行一些调整：

1. 你需要IMessage吗？

如果你有多个队列消息的实现，那么肯定，否则，如果消息只包含数据，也许这个接口可以省略。

2.解耦MessageQueueManager从Message

如果Message使用MessageQueueManager，那么对于依赖注入，您必须MessageQueueManager在创建消息时开始传递消息。假设您可能有很多地方在不知道队列管理器的情况下创建消息，MessageQueueManager作为参数传递可能是一个巨大的变化。你可能想避免这样做。

让我们假设当一条消息可以被解除时，它应该已经在一个或多个队列中。在这种情况下，我们可以委托解雇行动的队列，在该消息得到了增加，这是有道理的，消息队列知道他们的经理。

所以你需要这样的东西：

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。

就像您已经尝试过的（注入queueConstructor）一样，正如其他人所说，您需要这样做，

使用工厂。

这个工厂在这里应该是你自己的工厂为每依赖倒置原则。您应该避免使用任何特定ILifetimeScope于DI 框架的工厂，例如Autofac 中的 。这是因为依赖注入是一种工具，应该是可选的。您需要依赖倒置而不是依赖注入。所以我建议你不要将你的类型绑定到一个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);
    }
}

如果您需要将特定于框架的工厂注入MessageQueueMessageQueueFactory.

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

请注意，因为我们要使用依赖注入，MessageQueueManager现在使用IMessageQueueFactory，所以我们需要将它从真正的单例改为 DI 单例，通过删除Instance属性并将类型注册为单例

5. 需要处理队列族吗？

假设您有多个队列实现，您可能不想混淆队列特定类型。例如，您不希望将 RabbitMQ 消息添加到 MSMQ 队列。如果是这种情况，您可以使用抽象工厂模式：

public interface IMessageQueueProvider
{ 
    IMessageQueueManager CreateManager();
    IMessageQueueFactory CreateFactory();
    IMessage CreateMessage();
}

但是，这有点超出范围。

最后

注册新类型。我以微软扩展依赖注入为例：

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