多服务合设放到一个容器中可以吗一个服务多个实例

转载

definitely 2024-06-28 19:58:41

文章标签 多服务合设放到一个容器中可以吗 ide 生命周期管理封装 文章分类 云原生云计算

上述任何服务注册方法都可用于注册同一服务类型的多个服务实例。下面的示例以 IMyDependency 作为服务类型调用 AddSingleton 两次。第二次对 AddSingleton 的调用在解析为 IMyDependency 时替代上一次调用，在通过 IEnumerable<IMyDependency> 解析多个服务时添加到上一次调用。通过 IEnumerable<{SERVICE}> 解析服务时，服务按其注册顺序显示。

(); language-php
services.AddSingleton();

public class MyService
{
    public MyService(IMyDependency myDependency, 
       IEnumerable myDependencies)
    {
        Trace.Assert(myDependency is DifferentDependency);

        var dependencyArray = myDependencies.ToArray();
        Trace.Assert(dependencyArray[0] is MyDependency);
        Trace.Assert(dependencyArray[1] is DifferentDependency);
    }
}
">services.AddSingleton<IMyDependency, MyDependency>();
services.AddSingleton<IMyDependency, DifferentDependency>();

public class MyService
{
    public MyService(IMyDependency myDependency, 
       IEnumerable<IMyDependency> myDependencies)
    {
        Trace.Assert(myDependency is DifferentDependency);

        var dependencyArray = myDependencies.ToArray();
        Trace.Assert(dependencyArray[0] is MyDependency);
        Trace.Assert(dependencyArray[1] is DifferentDependency);
    }
}


生命周期：

3:     static void Main(string[] args)

4:     {

5:         IServiceProvider serviceProvider1 = new ServiceCollection().BuildServiceProvider();

6:         IServiceProvider serviceProvider2 = serviceProvider1.GetService<IServiceScopeFactory>().CreateScope().ServiceProvider;

7:

8:         object root = serviceProvider2.GetType().GetField("_root", BindingFlags.Instance| BindingFlags.NonPublic).GetValue(serviceProvider2);

9:         Debug.Assert(object.ReferenceEquals(serviceProvider1, root));

10:     }

11: }

如果读者朋友们希望进一步了解ServiceScope的创建以及它和ServiceProvider之间的关系，我们不妨先来看看作为IServiceScope接口默认实现的内部类型ServiceScope的定义。如下面的代码片段所示，ServiceScope仅仅是对一个ServiceProvider对象的简单封装而已。值得一提的是，当ServiceScope的Dispose方法被调用的时候，这个被封装的ServiceProvider的同名方法同时被执行。

1: {

2:     private readonly ServiceProvider _scopedProvider;

3:     public ServiceScope(ServiceProvider scopedProvider)

4:     {

5:         this._scopedProvider = scopedProvider;

6:     }

7:

8:     public void Dispose()

9:     {

10:         _scopedProvider.Dispose();

11:     }

12:

13:     public IServiceProvider ServiceProvider

14:     {

15:         get {return _scopedProvider; }

16:     }

17: }

IServiceScopeFactory接口的默认实现类型是一个名为ServiceScopeFactory的内部类型。如下面的代码片段所示，ServiceScopeFactory的只读字段“_provider”表示当前的ServiceProvider。当CreateScope方法被调用的时候，这个ServiceProvider的“子ServiceProvider”被创建出来，并被封装成返回的ServiceScope对象。

1: internal class ServiceScopeFactory : IServiceScopeFactory

2: {

3:     private readonly ServiceProvider _provider;

4:     public ServiceScopeFactory(ServiceProvider provider)

5:     {

6:         _provider = provider;

7:     }

8:

9:     public IServiceScope CreateScope()

10:     {

11:         return new ServiceScope(new ServiceProvider(_provider));

12:     }

13: }

三种生命周期管理模式

只有在充分了解ServiceScope的创建过程以及它与ServiceProvider之间的关系之后，我们才会对ServiceProvider支持的三种生命周期管理模式（Singleton、Scope和Transient）具有深刻的认识。就服务实例的提供方式来说，它们之间具有如下的差异：

Singleton：ServiceProvider创建的服务实例保存在作为根节点的ServiceProvider上，所有具有同一根节点的所有ServiceProvider提供的服务实例均是同一个对象。
Scoped：ServiceProvider创建的服务实例由自己保存，所以同一个ServiceProvider对象提供的服务实例均是同一个对象。
Transient：针对每一次服务提供请求，ServiceProvider总是创建一个新的服务实例。

为了让读者朋友们对ServiceProvider支持的这三种不同的生命周期管理模式具有更加深刻的理解，我们照例来做一个简单的实例演示。我们在一个控制台应用中定义了如下三个服务接口（IFoo、IBar和IBaz）以及分别实现它们的三个服务类(Foo、Bar和Baz)。

1: public interface IFoo {}

2: public interface IBar {}

3: public interface IBaz {}

4:

5: public class Foo : IFoo {}

6: public class Bar : IBar {}

7: public class Baz : IBaz {}

现在我们在作为程序入口的Main方法中创建了一个ServiceCollection对象，并采用不同的生命周期管理模式完成了针对三个服务接口的注册(IFoo/Foo、IBar/Bar和IBaz/Baz分别Transient、Scoped和Singleton)。我们接下来针对这个ServiceCollection对象创建了一个ServiceProvider（root），并采用创建ServiceScope的方式创建了它的两个“子ServiceProvider”（child1和child2）。

1: class Program

2: {

3:     static void Main(string[] args)

4:     {

5:         IServiceProvider root = new ServiceCollection()

6:             .AddTransient<IFoo, Foo>()

7:             .AddScoped<IBar, Bar>()

8:             .AddSingleton<IBaz, Baz>()

9:             .BuildServiceProvider();

10:         IServiceProvider child1 = root.GetService<IServiceScopeFactory>().CreateScope().ServiceProvider;

11:         IServiceProvider child2 = root.GetService<IServiceScopeFactory>().CreateScope().ServiceProvider;

12:

13:         Console.WriteLine("ReferenceEquals(root.GetService<IFoo>(), root.GetService<IFoo>() = {0}",ReferenceEquals(root.GetService<IFoo>(), root.GetService<IFoo>()));

14:         Console.WriteLine("ReferenceEquals(child1.GetService<IBar>(), child1.GetService<IBar>() = {0}",ReferenceEquals(child1.GetService<IBar>(), child1.GetService<IBar>()));

15:         Console.WriteLine("ReferenceEquals(child1.GetService<IBar>(), child2.GetService<IBar>() = {0}",ReferenceEquals(child1.GetService<IBar>(), child2.GetService<IBar>()));

16:         Console.WriteLine("ReferenceEquals(child1.GetService<IBaz>(), child2.GetService<IBaz>() = {0}",ReferenceEquals(child1.GetService<IBaz>(), child2.GetService<IBaz>()));

17:     }

18: }

为了验证ServiceProvider针对Transient模式是否总是创建新的服务实例，我们利用同一个ServiceProvider（root）获取针对服务接口IFoo的实例并进行比较。为了验证ServiceProvider针对Scope模式是否仅仅在当前ServiceScope下具有“单例”的特性，我们先后比较了同一个ServiceProvider（child1）和不同ServiceProvider（child1和child2）两次针对服务接口IBar获取的实例。为了验证具有“同根”的所有ServiceProvider针对Singleton模式总是返回同一个服务实例，我们比较了两个不同child1和child2两次针对服务接口IBaz获取的服务实例。如下所示的输出结构印证了我们上面的论述。

1: ReferenceEquals(root.GetService<IFoo>(), root.GetService<IFoo>()         = False

2: ReferenceEquals(child1.GetService<IBar>(), child1.GetService<IBar>()     = True

3: ReferenceEquals(child1.GetService<IBar>(), child2.GetService<IBar>()     = False

4: ReferenceEquals(child1.GetService<IBaz>(), child2.GetService<IBaz>()     = True

服务实例的回收

ServiceProvider除了为我们提供所需的服务实例之外，对于由它提供的服务实例，它还肩负起回收之责。这里所说的回收与.NET自身的垃圾回收机制无关，仅仅针对于自身类型实现了IDisposable接口的服务实例，所谓的回收仅仅体现为调用它们的Dispose方法。ServiceProvider针对服务实例所采用的收受策略取决于服务注册时采用的生命周期管理模式，具体采用的服务回收策略主要体现为如下两点：

如果注册的服务采用Singleton模式，由某个ServiceProvider提供的服务实例的回收工作由作为根的ServiceProvider负责，后者的Dispose方法被调用的时候，这些服务实例的Dispose方法会自动执行。
如果注册的服务采用其他模式（Scope或者Transient），ServiceProvider自行承担由它提供的服务实例的回收工作，当它的Dispose方法被调用的时候，这些服务实例的Dispose方法会自动执行。

我们照例使用一个简单的实例来演示ServiceProvider针对不同生命周期管理模式所采用的服务回收策略。我们在一个控制台应用中定义了如下三个服务接口（IFoo、IBar和IBaz）以及三个实现它们的服务类（Foo、Bar和Baz），这些类型具有相同的基类Disposable。Disposable实现了IDisposable接口，我们在Dispose方法中输出相应的文字以确定对象回收的时机。

1: public interface IFoo {}

2: public interface IBar {}

3: public interface IBaz {}

4:

5: public class Foo : Disposable, IFoo {}

6: public class Bar : Disposable, IBar {}

7: public class Baz : Disposable, IBaz {}

8:

9: public class Disposable : IDisposable

10: {

11:     public void Dispose()

12:     {

13:         Console.WriteLine("{0}.Dispose()", this.GetType());

14:     }

15: }

我们在作为程序入口的Main方法中创建了一个ServiceCollection对象，并在其中采用不同的生命周期管理模式注册了三个相应的服务（IFoo/Foo、IBar/Bar和IBaz/Baz分别采用Transient、Scoped和Singleton模式）。我们针对这个ServiceCollection创建了一个ServiceProvider（root），以及它的两个“儿子”（child1和child2）。在分别通过child1和child2提供了两个服务实例（child1：IFoo， child2：IBar/IBaz）之后，我们先后调用三个ServiceProvider（child1=>child2=>root）的Dispose方法。

1: class Program

2: {

3:     static void Main(string[] args)

4:     {

5:         IServiceProvider root = new ServiceCollection()

6:             .AddTransient<IFoo, Foo>()

7:             .AddScoped<IBar, Bar>()

8:             .AddSingleton<IBaz, Baz>()

9:             .BuildServiceProvider();

10:         IServiceProvider child1 = root.GetService<IServiceScopeFactory>().CreateScope().ServiceProvider;

11:         IServiceProvider child2 = root.GetService<IServiceScopeFactory>().CreateScope().ServiceProvider;

12:

13:         child1.GetService<IFoo>();

14:         child1.GetService<IFoo>();

15:         child2.GetService<IBar>();

16:         child2.GetService<IBaz>();

17:

18:         Console.WriteLine("child1.Dispose()");

19:         ((IDisposable)child1).Dispose();

20:

21:         Console.WriteLine("child2.Dispose()");

22:         ((IDisposable)child2).Dispose();

23:

24:         Console.WriteLine("root.Dispose()");

25:         ((IDisposable)root).Dispose();

26:     }

27: }

该程序运行之后会在控制台上产生如下的输出结果。从这个结果我们不难看出由child1提供的两个采用Transient模式的服务实例的回收实在child1的Dispose方法执行之后自动完成的。当child2的Dispose方法被调用的时候，对于由它提供的两个服务对象来说，只有注册时采用Scope模式的Bar对象被自动回收了，至于采用Singleton模式的Baz对象的回收工作，是在root的Dispose方法被调用之后自动完成的。

1: child1.Dispose()

2: Foo.Dispose()

3: Foo.Dispose()

4: child2.Dispose()

5: Bar.Dispose()

6: root.Dispose()

7: Baz.Dispose()

了解ServiceProvider针对不同生命周期管理模式所采用的服务回收策略还会帮助我们正确的使用它。具体来说，当我们在使用一个现有的ServiceProvider的时候，由于我们并不能直接对它实施回收（因为它同时会在其它地方被使用），如果直接使用它来提供我们所需的服务实例，由于这些服务实例可能会在很长一段时间得不到回收，进而导致一些内存泄漏的问题。如果所用的是一个与当前应用具有相同生命周期（ServiceProvider在应用终止的时候才会被回收）的ServiceProvider，而且提供的服务采用Transient模式，这个问题就更加严重了，这意味着每次提供的服务实例都是一个全新的对象，但是它永远得不到回收。

为了解决这个问题，我想很多人会想到一种解决方案，那就是按照如下所示的方式显式地对提供的每个服务实例实施回收工作。实际上这并不是一种推荐的编程方式，因为这样的做法仅仅确保了服务实例对象的Dispose方法能够被及时调用，但是ServiceProvider依然保持着对服务实例的引用，后者依然不能及时地被GC回收。

1: public void DoWork(IServiceProvider serviceProvider)

2: {

3:     using (IFoobar foobar = serviceProvider.GetService<IFoobar>())

4:     {

5:         ...

6:     }

7: }

或者

1: public void DoWork(IServiceProvider serviceProvider)

2: {

3:     IFoobar foobar = serviceProvider.GetService<IFoobar>();

4:     try

5:     {

6:         ...

7:     }

8:     finally

9:     {

10:         (foobar as IDisposable)?.Dispose();

11:     }

12: }

由于提供的服务实例总是被某个ServiceProvider引用着[1]（直接提供服务实例的ServiceProvider或者是它的根），所以服务实例能够被GC从内存及时回收的前提是引用它的ServiceProvider及时地变成垃圾对象。要让提供服务实例的ServiceProvider成为垃圾对象，我们就必须创建一个新的ServiceProvider，通过上面的介绍我们知道ServiceProvider的创建可以通过创建ServiceScope的方式来实现。除此之外，为我们可以通过回收ServiceScope的方式来回收对应的ServiceProvider，进而进一步回收由它提供的服务实例（仅限Transient和Scoped模式）。下面的代码片段给出了正确的编程方式。

1: public void DoWork(IServiceProvider serviceProvider)

2: {

3:     using (IServiceScope serviceScope = serviceProvider.GetService<IServiceScopeFactory>().CreateScope())

4:     {

5:         IFoobar foobar = serviceScope.ServiceProvider.GetService<IFoobar>();

6:         ...

7:     }

8: }

接下来我们通过一个简单的实例演示上述这两种针对服务回收的编程方式之间的差异。我们在一个控制台应用中定义了一个继承自IDisposable的服务接口IFoobar和实现它的服务类Foobar。如下面的代码片段所示，为了确认对象真正被GC回收的时机，我们为Foobar定义了一个析构函数。在该析构函数和Dispose方法中，我们还会在控制台上输出相应的指导性文字。

1: public interface IFoobar: IDisposable

2: {}

3:

4: public class Foobar : IFoobar

5: {

6:     ~Foobar()

7:     {

8:         Console.WriteLine("Foobar.Finalize()");

9:     }

10:

11:     public void Dispose()

12:     {

13:         Console.WriteLine("Foobar.Dispose()");

14:     }

15: }

在作为程序入口的Main方法中，我们创建了一个ServiceCollection对象并采用Transient模式将IFoobbar/Foobar注册其中。借助于通过该ServiceCollection创建的ServiceProvider，我们分别采用上述的两种方式获取服务实例并试图对它实施回收。为了强制GC试试垃圾回收，我们显式调用了GC的Collect方法。

1: class Program

2: {

3:     static void Main(string[] args)

4:     {

5:         IServiceProvider serviceProvider = new ServiceCollection()

6:             .AddTransient<IFoobar, Foobar>()

7:             .BuildServiceProvider();

8:

9:         serviceProvider.GetService<IFoobar>().Dispose();

10:         GC.Collect();

11:

12:         Console.WriteLine("----------------");

13:         using (IServiceScope serviceScope = serviceProvider.GetService<IServiceScopeFactory>().CreateScope())

14:         {

15:             serviceScope.ServiceProvider.GetService<IFoobar>();

16:         }

17:         GC.Collect();

18:

19:         Console.Read();

20:     }

21: }

该程序执行之后会在控制台上产生如下所示的输出结果。从这个结果我们可以看出，如果我们使用现有的ServiceProvider来提供所需的服务实例，后者在GC进行垃圾回收之前并不会从内存中释放。如果我们利用现有的ServiceProvider创建一个ServiceScope，并利用它所在的ServiceProvider来提供我们所需的服务实例，GC是可以将其从内存中释放出来的。

1: Foobar.Dispose()

2: ----------------

3: Foobar.Dispose()

4: Foobar.Finalize()

[1] 对于分别采用 Scoped和Singleton模式提供的服务实例，当前ServiceProvider和根ServiceProvider分别具有对它们的引用。如果采用Transient模式，只有服务类型实现了IDisposable接口，当前ServiceProvider才需要对它保持引用以完成对它们的回收，否则没有任何一个ServiceProvider保持对它们的引用。

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。