为什么依赖注入框架支持容器层次结构？-WhydoDependencyInjectionframeworkssupportcontainerhierarchies?

Here's a sample that uses child containers in a scenario similar to the one Matt describes. It uses child containers to select between different database configurations.

这是一个在类似于Matt描述的场景中使用子容器的示例。它使用子容器在不同的数据库配置之间进行选择。

The key here is that most of the configuration is shared between the child containers (that shared part belongs in the parent container)

这里的关键是大多数配置在子容器之间共享(共享部分属于父容器)

I left a comment on kzu's blog asking the same question. It's a shame he didn't clarify the use-case for such a feature before coding it.

我在kzu的博客上留下了一个评论问同样的问题。令人遗憾的是,他在编码之前没有澄清这种功能的用例。

The only thing I could think of is if you wanted to have different types resolved from your container in different parts of your app. For example, if you had an order-entry system with two separate sections, and each section was identical except that they needed to present a different product list, you could create a child container for each section, and "override" the registration of your product repository in each. Whenever a section tried to resolve a product repository (or anything that depended on one) it would get the instance you set up in the child container rather than the parent. Sort of like overriding a virtual method.

我唯一能想到的是,如果你想在应用程序的不同部分从容器中解析出不同的类型。例如,如果您有一个包含两个单独部分的订单输入系统,并且每个部分都相同,只是他们需要提供不同的产品列表,您可以为每个部分创建一个子容器,并“覆盖”您的注册每个产品库。每当某个部分试图解析产品存储库(或任何依赖于它的东西)时,它将获得您在子容器而不是父容器中设置的实例。有点像重写虚拟方法。

This might be way off base, but it's the best I could come up with.

这可能是偏离基础的,但这是我能想到的最好的。

There is good reason for having child containers if dependency injection is fully embraced by the project. Let's imagine an application that has processes messages from two different, but similar systems. Most of the processing is similar, but there are variations to support compatability from those systems. Our aim is to re-use the code we can, while writing different code as requirements differ.

如果项目完全接受依赖注入,那么拥有子容器是有充分理由的。让我们假设一个应用程序处理来自两个不同但类似系统的消息。大多数处理都是类似的,但是有一些变化可以支持这些系统的兼容性。我们的目标是重用我们可以使用的代码,同时根据需求编写不同的代码。

In OO programming, we wire together a series of classes that will collaborate to meet the system requirements. The DI container takes this responsibility. When a message arrives from a system, we want to build a set of collaborating classes suitable for processing a message from that particular system.

在面向对象编程中,我们将一系列类连接在一起,以协作满足系统要求。 DI容器承担这一责任。当消息从系统到达时,我们希望构建一组适合处理来自该特定系统的消息的协作类。

We have a top level container which has items that do not vary between the two systems. Then, we have child containers that do vary between systems. When a message arrives, we ask the approriate child DI container for a messageProcessor. Based on the configuration of that container (falling back to the parent container as necessary) the DI framework can return a messageProcessor (being an object backed by approriate collaborators) for the system in question.

我们有一个顶级容器,其中包含两个系统之间不同的项目。然后,我们有不同系统的子容器。当消息到达时,我们向approriate child DI容器询问messageProcessor。根据该容器的配置(根据需要回退到父容器),DI框架可以为相关系统返回messageProcessor(是由合作伙伴支持的对象)。

Please leave a comment if this is not a clear answer. Also, you can search for "robot legs problem". Each leg is identical but one needs a left foot and the other needs a right foot. We could have a child DI container for each leg.

如果这不是一个明确的答案,请发表评论。此外,您可以搜索“机器人腿问题”。每条腿都相同,但一只需要左脚,另一只需要右脚。我们每条腿都可以有一个儿童DI容器。

The best example that I'm aware of for nested containers is a windowing system. It's very nice for just separation of concerns to have each tab/window have it's own container independent of the other tabs/windows, with all window containers inheriting global dependencies from a parent container.

我知道嵌套容器的最好例子是一个窗口系统。只关注问题的分离是非常好的,让每个选项卡/窗口都拥有独立于其他选项卡/窗口的自己的容器,所有窗口容器都从父容器继承全局依赖关系。

This is especially needed if you can have duplicate tab/windows, since in many cases you want to distinct instances of various classes for each duplicate tab/window

如果您可以有重复的选项卡/窗口,则尤其需要这样做,因为在许多情况下,您希望为每个重复的选项卡/窗口显示不同类的不同实例