2

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

一切正常，但是我今天在从此处获取的示例代码中尝试使用Scopes like 时遇到了问题

// 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是不同的！！！我错过了什么吗？

4

0 回答 0