Question

我在DryIoC容器周围创建了一个包装器，它只是一个将任务委托给DryIoC方法的类（例如，myContainer.Register<T>()将调用dryIoC.Register<T>()）。目标只是隐藏我的界面背后的真实实现，以便我可以切换到另一个DI容器。

一切正常，但今天我遇到了一个问题，当我尝试使用范围喜欢这个示例代码来自here

// example using DryIoC
var container = new Container();
container.Register<B>();

using (var scope = container.OpenScope())
{
    var a = new A();
    scope.UseInstance(a); // Scoped

    scope.Resolve<B>(); // will inject `a`
}

var anotherA = new A();
container.UseInstance(anotherA); // Singleton
container.Resolve<B>(); // will inject `anotherA`

我天真的包装器实现是创建另一个接受DryIoC容器实例的构造函数，并按照以下方式执行：

    // My Wrapper class
    public Infrastructure.IMyContainer OpenScope()
    {
        return new MyContainer(dryIoC.OpenScope());
    }

我的理解是dryIoC.OpenScope()返回容器的新实例，所以我所要做的就是在内部保存这个实例并用它来解析我的类。但是这个实现对我来说不起作用，这是我的单元测试：

[Test]
public void OpenScope_Creates_A_Scoped_Container()
{
    var _container = new MyContainer();
    _container.Register<IMyInterface, MyImpl>();
    _container.Register<MyDependingClass>();
    MyDependingClass cls1 = null;
    MyDependingClass cls2 = null;
    var dep = new MyImpl();
    using (var scope = _container.OpenScope())
    {
        scope.UseInstance(dep);
        cls1 = scope.Resolve<MyDependingClass>(); // this should inject 'dep' instance created in the line before the creation of the scope
    }

    cls2 = _container.Resolve<MyDependingClass>(); // this should inject another instance.

    cls1.Dep.ShouldBeSameAs(dep); // cls1 was resolved in the scope, so it should get 'dep' instance
    cls1.Dep.ShouldNotBeSameAs(cls2.Dep); // cls2.Dep should be different
}

// stub classes/interfaces
class MyDependingClass
{
    public MyDependingClass(IMyInterface dep)
    {
        Dep = dep;
    }

    public IMyInterface Dep { get; }
}

class MyImpl : IMyInterface { }

但是这个测试在cls1.Dep.ShouldBeSameAs(dep);失败告诉我IMyInterface的两个实例是不同的!!! 我错过了什么吗？

如何在DryIoC container.OpenScope（）周围创建一个包装器？

0 个答案: