如何使用 IOC 容器构造对象

Question

我相信我对依赖注入有足够的了解，可以开始使用它，但是我无法理解 IOC 容器与服务位置，以及如何使用容器构造我的对象。

给定：

public interface IFooService
{
    void DoSomethingFooey();
}
public class FooService : IFooService
{
    readonly IBarService _barService;

    public FooService(IBarService barService)
    {
        this._barService = barService;
    }

    public void DoSomethingFooey()
    {
        // some stuff
        _barService.DoSomethingBarey();
    }
}


public interface IBarService
{
    void DoSomethingBarey();
}
public class BarService : IBarService
{
    readonly IBazService _bazService;

    public BarService(IBazService bazService)
    {
        this._bazService = bazService;
    }

    public void DoSomethingBarey()
    {
        // Some more stuff before doing ->
        _bazService.DoSomethingBazey();
    }
}


public interface IBazService
{
    void DoSomethingBazey();
}
public class BazService : IBazService
{
    public void DoSomethingBazey()
    {
        Console.WriteLine("Blah blah");
    }
}

如果没有 IOC 容器，我将不得不在构建时提供所有依赖项，如下所示：

    public void DoStuff()
    {
        // Without a container, I would have to do something yucky like:
        FooService fs = new FooService(
            new BarService(
                new BazService()
            )
        );

        // or
        BazService bazService = new BazService();
        BarService barService = new BarService(bazService);
        FooService fooService = new FooService(barService);
    }

通过以这种 DI 方式构建我的类，我似乎收获了很多，因为我现在可以独立测试我的类，而在使用 DI 之前我真的不能。

但是根据我正在阅读的有关执行 DI 的“正确方法”的内容，我会使用 Unity 或 StructureMap 之类的 IOC 容器......但我还没有找到我需要了解如何开始的确切内容。

我假设我的容器看起来像这样：

var container = new Container(_ =>
{
    _.For<IFooService>().Use<FooService>();
    _.For<IBarService>().Use<BarService>();
    _.For<IBazService>().Use<BazService>();
});

取自以下示例：http://structuremap.github.io/quickstart/

基于上面的例子，我不确定包含var container... 的方法的签名是什么样的，或者它是如何被调用并保持在范围内的。或许更重要的是如何利用容器实际构造对象。

如果我想创建FooService 的实例（然后是BarService 和BazSerivce），我的DoStuff() 现在会是什么样子？

以前是：

public void DoStuff()
{
    // Without a container, I would have to do something yucky like:
    FooService fs = new FooService(
        new BarService(
            new BazService()
        )
    );

    // or...
}

但是现在使用我的容器会是什么样子？我的方法如何知道在哪里寻找我的容器？

希望我在某种程度上走在正确的轨道上，但如果我不是，请告诉我，以及我缺少什么。

Answer 1

我通常这样做是为了保留 DI 并避免 IOC 容器的缺点：

public interface IFooService
{
    void DoSomethingFooey();
}
public class FooService : IFooService
{
    readonly IBarService _barService;

    public FooService() : this(new BarService()) {}

    public FooService(IBarService barService)
    {
        this._barService = barService;
    }

    public void DoSomethingFooey()
    {
        // some stuff
        _barService.DoSomethingBarey();
    }
}


public interface IBarService
{
    void DoSomethingBarey();
}
public class BarService : IBarService
{
    readonly IBazService _bazService;

    public BarService() : this(new BazService()) {}

    public BarService(IBazService bazService)
    {
        this._bazService = bazService;
    }

    public void DoSomethingBarey()
    {
        // Some more stuff before doing ->
        _bazService.DoSomethingBazey();
    }
}


public interface IBazService
{
    void DoSomethingBazey();
}
public class BazService : IBazService
{
    public void DoSomethingBazey()
    {
        Console.WriteLine("Blah blah");
    }
}

Answer 2

修改为使用容器的 DoStuff 方法如下所示：

public void DoStuff()
{
    IFooService fooService = container.GetInstance<IFooService>();

    // do something with fooService
}

我是根据您引用的 StructureMap 链接得出的。其他 IoC 容器以不同的方式命名其等效的“GetInstance”方法。

您通常不会在尝试获取IFooService 实例的相同方法中创建container。通常，您会在某些初始化方法中在其他地方配置容器，并将容器保存在您可以轻松访问的地方，例如静态属性中。因此，您的 DoStuff 方法可能看起来更像这样：

public void DoStuff()
{
    IFooService fooService = MyIoCContainer.Current.Getinstance<IFooService>();

    // do something with fooService
}

其中MyIoCContainer 只是您定义的一个类，其Current 属性是您在初始化期间配置的StructureMap 容器。

但是，您并不总是需要编写这样的代码才能获得服务。一些框架提供了使用 IoC 容器的钩子，以便您在整个类中继续使用依赖注入，并且框架负责使用 IoC 容器实例化您的类。

仅举一个例子，ASP.NET MVC 框架提供了一个IDependencyResolver 接口和DependencyResolver 类，您可以使用它们来允许该框架在您的Web 应用程序中实例化您的控制器类时使用您的IoC 容器。这样，您可以继续在控制器中使用依赖注入，因此根本不需要在控制器中显式引用您的 IoC 容器。请参阅 this section on "Including a Custom Dependency Resolver" 了解如何实现。

因此，理想情况下，您的 DoStuff 方法及其包含的类应该是这样的，这只是依赖注入的进一步延续。接下来的问题是这个MyStuffDoer 类是如何被实例化的：要么是通过一个了解如何使用你的 IoC 容器来创建它的框架，要么是你在某处编写一些显式代码来从 IoC 容器中实例化它。

class MyStuffDoer
{
    IFooService fooService;

    public MyStuffDoer(IFooService fooService)
    {
        this.fooService = fooService;
    }

    public void DoStuff()
    {
        // do something with fooService
    }
}