C# 范围和重用

我想注册两个服务，

A

和

B

，它们的生命周期不同

我的用例类似于“浏览器”和“选项卡”。
我在可执行生命周期（浏览器）中有一个作用域，每个选项卡有一个“子作用域”。
我希望

A

成为浏览器范围（浏览器生命周期）中的一员。
现在我想在每个选项卡中解析不同的

B

，但相同的

a

。
我已经阅读了GitHub文档，但看起来我会在每个选项卡中获得一个新的

a

伪代码如下所示：

var container=newcontainer（）；
容器。寄存器（重用。作用域）；
容器。寄存器（重用。作用域）；
使用（var browserScope=container.OpenScope（））
{
使用（var tabScope1=browserScope.OpenScope（））
{
var a1=tabScope1.Resolve（）；
var b1=tabScope1.Resolve（）；
}
使用（var tabScope2=browserScope.OpenScope（））
{
var a2=tabScope2.Resolve（）；
var b2=tabScope2.Resolve（）；
}
}

我希望将

a1

和

a2

解析为同一个实例。

---

我怎样才能做到这一点呢？

好的，所以我最后做的是：

var container = new Container();
container.Register<A>(Reuse.Singleton);
container.Register<B>(Reuse.Scoped);

using (var tabScope1 = container.OpenScope())
{
    var b1 = tabScope1.Resolve<B>();
}
using (var tabScope2 = container.OpenScope())
{
    var b2 = tabScope2.Resolve<B>();
}

class A { }

class B
{
    private readonly A _a;

    public B(A a) { _a = a; }
}

var container=newcontainer（）；
容器.寄存器（重用.单例）；
容器。寄存器（重用。作用域）；
使用（var tabScope1=container.OpenScope（））
{
var b1=tabScope1.Resolve（）；
}
使用（var tabScope2=container.OpenScope（））
{
var b2=tabScope2.Resolve（）；
}
A类{}
B类
{
私人只读A_A；
公共B（A）{u A=A；}
}

B的两个实例

都获得了

A的相同实例

---

这可能不是最优雅的解决方案，但它对我来说是有效的：）

您可以通过以下命名范围实现它-live示例

全文来源：

using System;
using DryIoc;

public class Program
{
    class A { }
    class B { }

    enum UIScope { Browser, Tab }

    public static void Main()
    {
        var container = new Container(r => r.WithUseInterpretation());
        container.Register<A>(Reuse.ScopedTo(UIScope.Browser));
        container.Register<B>(Reuse.ScopedTo(UIScope.Tab));

        using (var browserScope = container.OpenScope(UIScope.Browser))
        {
            A a1, a2;
            using (var tabScope1 = browserScope.OpenScope(UIScope.Tab))
            {
                a1 = tabScope1.Resolve<A>();
                var b1 = tabScope1.Resolve<B>();
            }

            using (var tabScope2 = browserScope.OpenScope(UIScope.Tab))
            {
                a2 = tabScope2.Resolve<A>();
                var b2 = tabScope2.Resolve<B>();
            }

            Console.WriteLine(a1 == a2);
        }
    }
}

使用系统；
使用DryIoc；
公共课程
{
A类{}
B类{}
枚举UIScope{浏览器，选项卡}
公共静态void Main（）
{
var container=新容器（r=>r.WithUseExpression（））；
container.Register（重用.ScopedTo（UIScope.Browser））；
Register（重用.ScopedTo（UIScope.Tab））；
使用（var browserScope=container.OpenScope（UIScope.Browser））
{
A a1，a2；
使用（var tabScope1=browserScope.OpenScope（UIScope.Tab））
{
a1=选项卡范围1.Resolve（）；
var b1=tabScope1.Resolve（）；
}
使用（var tabScope2=browserScope.OpenScope（UIScope.Tab））
{
a2=选项卡范围2.Resolve（）；
var b2=tabScope2.Resolve（）；
}
控制台写入线（a1==a2）；
}
}
}

太好了，谢谢！使用WithUseTranslation的好处是什么？我读了它，我节省了启动程序的时间？但我在运行时是否会浪费时间？我在这里添加了UseExpression，因为dotnetfiddle存在反射问题。Emit

WithUseExpression

比编译委托慢10倍，但在第二次解析某个内容时，编译成本为100倍-第一次总是使用Interertation。

using System;
using DryIoc;

public class Program
{
    class A { }
    class B { }

    enum UIScope { Browser, Tab }

    public static void Main()
    {
        var container = new Container(r => r.WithUseInterpretation());
        container.Register<A>(Reuse.ScopedTo(UIScope.Browser));
        container.Register<B>(Reuse.ScopedTo(UIScope.Tab));

        using (var browserScope = container.OpenScope(UIScope.Browser))
        {
            A a1, a2;
            using (var tabScope1 = browserScope.OpenScope(UIScope.Tab))
            {
                a1 = tabScope1.Resolve<A>();
                var b1 = tabScope1.Resolve<B>();
            }

            using (var tabScope2 = browserScope.OpenScope(UIScope.Tab))
            {
                a2 = tabScope2.Resolve<A>();
                var b2 = tabScope2.Resolve<B>();
            }

            Console.WriteLine(a1 == a2);
        }
    }
}