C# 创建整体IoC容器

我在项目中使用IoC容器，但我的项目包含许多子模块。我想使用一个基本的IoC模块。 例子： 我在子模块A中有两个接口 它是IOne和ITwo接口

public interface ITwo
{
     // some code
}

public interface IOne
{
     // some code
}

和我的SimpleInjectorRegisterTypes类

public class SimpleInjectorRegisterTypes : ISimpleInjectorRegistration
    {
        public void Register(Container container)
        {
            container.RegisterSingle<ITwo, Two>();
            container.RegisterSingle<IOne, One>();
        }
    }

公共类SimpleInjectorRegisterTypes:ISimpleInjectorRegistration
{
公众作废登记册（货柜）
{
container.RegisterSingle（）；
container.RegisterSingle（）；
}
}

还有主类，在这里我使用我的逻辑

private static IOne _one;
        private static ITwo _two;

        static void Main(string[] args)
        {
            Container container = new Container();
            new SimpleInjectorRegisterTypes().Register(container);
            _one= container.GetInstance<IOne>();
            _two= container.GetInstance<ITwo>();
        }

private static IOne\u one；
私有静态ITwo_2；
静态void Main（字符串[]参数）
{
容器=新容器（）；
新的SimpleInjectorRegisterTypes（）.Register（容器）；
_一个=container.GetInstance（）；
_two=container.GetInstance（）；
}

这很好，但我有子模块B，其中我有接口IThree和TFour 还有SimpleInjectorRegisterTypes和main类。 如何为我的所有子模块编写通用IoC容器？

---

注意：对于IoC，我使用

假设有3个子组件，例如，

通用

，

模块A

和

模块B

• Common

  具有

  ICommon

  界面，您的

  是简单的InjectorRegistration

  界面

• ModuleA

  具有

  CommonA

  实现

  ICommon

  ，及其独立注册（

  IOne

  ：

  One

  ，

  ITwo

  ：

  Two

  ）

• ModuleB

  具有

  CommonB

  实现

  ICommon

  ，及其注册（

  itree

  ：

  三个

  ，

  如果四个

  ：

  四个

  ）

ModuleA

按如下方式注册：

public class RegistrationA : ISimpleInjectorRegistration
{
    public void Register(Container container)
    {
        container.Register<IOne, One>();
        container.Register<ITwo, Two>();
        container.Register<ICommon, CommonA>();
        container.RegisterAll<ICommon>(typeof(CommonA));
    }
}

public class RegistrationB : ISimpleInjectorRegistration
{
    public void Register(Container container)
    {
        container.Register<IThree, Three>();
        container.Register<IFour, Four>();
        container.Register<ICommon, CommonB>();
        container.RegisterAll<ICommon>(typeof (CommonB));
    }
}

var container = new Container();
new ModuleA.RegistrationA().Register(container);
new ModuleB.RegistrationB().Register(container);
container.Verify();

现在，在主模块中，您可以这样做：

public class RegistrationA : ISimpleInjectorRegistration
{
    public void Register(Container container)
    {
        container.Register<IOne, One>();
        container.Register<ITwo, Two>();
        container.Register<ICommon, CommonA>();
        container.RegisterAll<ICommon>(typeof(CommonA));
    }
}

public class RegistrationB : ISimpleInjectorRegistration
{
    public void Register(Container container)
    {
        container.Register<IThree, Three>();
        container.Register<IFour, Four>();
        container.Register<ICommon, CommonB>();
        container.RegisterAll<ICommon>(typeof (CommonB));
    }
}

var container = new Container();
new ModuleA.RegistrationA().Register(container);
new ModuleB.RegistrationB().Register(container);
container.Verify();

但是它在

ModuleB

注册时失败，因为

ICommon

在两个注册中都是重复的

您可以使用

选项避免重复注册，并强制替换为最新注册。AllowOverridingRegistrations

：

var container2 = new Container();
container2.Options.AllowOverridingRegistrations = true;
new ModuleA.Registration().Register(container2);
new ModuleB.Registration().Register(container2);
container2.Options.AllowOverridingRegistrations = false;
container2.Verify();

var commonInstance2 = container2.GetInstance<ICommon>();
var commonInstances2 = container2.GetAllInstances<ICommon>();

因此，

commonInstance3

将是

CommonA

实例，

commonInstances3

将同时包含

CommonA

和

CommonB

实例

---

关键是，注册依赖项时应该保持简单。只有一个位置是理想的，但是如果您有独立的模块，并且每个模块都不知道彼此，那么知道这两个模块的“主”应该正确配置注册。

为什么要在多个位置注册依赖项？为什么不在您的应用程序入口点中进行所有的“引导”呢？因此您有：一个容器，在其中注册接口/类对，然后您有一个接口/类对正在进行上述注册-然后您使用所有这些只在一个静态类中创建两个静态接口实例。。。。这不是有点过分了吗？我有独立的模块，我已经（如果可能的话）创建了一个完整的IoC容器，怎么做？