瞬态对象中的依赖注入

Question

我想要一些关于如何通过依赖注入构造一些对象的建议。

我的大部分应用程序都是单例，将单例作为相互依赖注入非常简单。

但是，我有一种情况，我会动态生成一些依赖于多个单例的瞬态对象。

这是当前情况的一些 C# 伪代码：

// random singletons
public static class SingletonA {...}
public static class SingletonB {...}
public static class SingletonC {...}

// random objects that all need to depend on some subset of the above singletons
public class BaseTask {...}
public class TaskA : BaseTask {...}
public class TaskB : BaseTask {...}
public class TaskC : BaseTask {...}

public class Scheduler {
    public Scheduler() {
    }

    public void Start() {
        // When these tasks are created is actually really dependent on business logic,
        // and each task executes a bunch of internal logic.
        // Each Task can create more children Task at arbitrary times too.
        ...
        var taskA = new TaskA();
        ...
        var taskB = new TaskB();
        ...
        var taskC = new TaskC();
        ...
}

TaskA, TaskB, TaskC, ... 中都有调用单例方法的代码。此外，每个任务都可以构建新任务。

如果我使用依赖注入，我可以这样做：

public class Scheduler {
    private ISingletonA _singletonA;
    private ISingletonB _singletonB;
    ...

    public Scheduler(ISingletonA singletonA, ISingletonB singletonB, ...) {
        _singletonA = singletonA;
        _singletonB = singletonB;
        ...
    }

    public void Start() {
        ...
        var taskA = new TaskA(_singletonA, _singletonB, ...);
        ...
        var taskB = new TaskB(_singletonA, _singletonB, ...);
        ...
        var taskC = new TaskC(_singletonA, _singletonB, ...);
        ...
    }
}

这看起来很乱，所以我正在考虑将所有 TaskA、TaskB、TaskC 重构为一个通用类并制作类似工厂的东西：

public class Scheduler {
    public TaskFactory _taskFactory

    public Scheduler(TaskFactory taskFactory) {
        _taskFactory = taskFactory;
    }

    public void Start() {
        ...
        var taskA = _taskFactory.NewTaskA(_taskFactory);
        ...
        var taskB = _taskFactory.NewTaskB(_taskFactory);
        ...
        var taskC = _taskFactory.NewTaskC(_taskFactory);
        ...
    }
}

有更好的想法吗？如果不是，我认为这不是工厂模式。有更准确的名称吗？

Answer 1

我将定义一个工厂类，其唯一目的是构造您的 TaskX 对象，包括包含所有依赖项：

class MyTaskFactory : IMyTaskFactory
{
    private readonly ISingletonA _singletonA;
    private readonly ISingletonB _singletonB;

    public MyTaskFactory(ISingletonA singletonA, ISingletonB singletonB)
    {
        _singletonA = singletonA;
        _singletonB = singletonB;
    }

    public T Resolve<T>() where T : ITask
    {
        if (typeof(T) == typeof(TaskA)) return (T)(object)GetTaskA();
        if (typeof(T) == typeof(TaskB)) return (T)(object)GetTaskB();
        if (typeof(T) == typeof(TaskC)) return (T)(object)GetTaskC();

        throw new ArgumentException(string.Format("Type not supported: {0}", typeof(T).FullName));
    }

    protected TaskA GetTaskA()
    {
        return new TaskA(_singletonA);
    }

    protected TaskB GetTaskB()
    {
        return new TaskB(_singletonA, _singletonB);
    }

    protected TaskC GetTaskC()
    {
        return new TaskC(_singletonA, "Other runtime parameter");
    }
}

public class Scheduler
{
    protected readonly IMyTaskFactory _taskFactory;

    public Scheduler(IMyTaskFactory taskFactory)
    {
        _taskFactory = taskFactory;
    }

    public void Start()
    {
        var taskA = _taskFactory.Resolve<TaskA>();
        var taskB = _taskFactory.Resolve<TaskB>();
        var taskC = _taskFactory.Resolve<TaskC>();
    }
}

然后您将工厂添加到您的组合根目录中：

container.Register<IMyTaskFactory,MyTaskFactory>();

并且依赖项会显示在需要它们的地方。

单击here 获取包含可编译代码的 Fiddle。

Answer 2

如果我错了，请纠正我，但我认为你所做的类似于抽象工厂模式。

我不确定您希望应用程序可配置多深。我建议根据您当前的结构并根据您展示的内容创建一个应用程序文件，您可以在其中混合和匹配注射剂。

    {
        "Schedulers": [
            {
                "id": "A",
                "type": "....",
                "tasks": "tA, tB"
            },
            {
                "id": "B",
                "type": "....",
                "tasks": "tC"
            }
        ],
        "Tasks": [
            {
                "id": "tA",
                "type": "..."
            },
            {
                "id": "tB",
                "type": "..."
            },
            {
                "id": "tC",
                "type": "..."
            }
        ]
    }

基本思想是您可以将“任务”分配给您的“调度程序”。

但是，为了做到这一点，您需要使用另一个 IoC 容器，例如 Autofac，因为默认的 ASP.NET Core DI 容器使得这有点不可能实现。