[ASP.NET Core 3框架揭秘]服务承载系统[3]:总体设计[上篇]

服务承载系统[3]: 总体设计[上篇] - 图1前面的实例演示了服务承载的基本编程模式，接下来我们从设计的角度来重新认识服务承载模型。总的来说，服务承载模型主要由如下图所示的三个核心对象组成：多个通过IHostedService接口表示的服务被承载于通过IHost接口表示的宿主上，IHostBuilder接口表示IHost对象的构建者。

前面的实例演示了服务承载的基本编程模式，接下来我们从设计的角度来重新认识服务承载模型。总的来说，服务承载模型主要由如下图所示的三个核心对象组成：多个通过IHostedService接口表示的服务被承载于通过IHost接口表示的宿主上，IHostBuilder接口表示IHost对象的构建者。

10-7

一、IHostedService

承载的服务总是会被定义成IHostedService接口的实现类型。如下面的代码片段所示，该接口仅定义了两个用来启动和关闭自身服务的方法。当作为宿主的IHost对象被启动的时候，它会利用依赖注入框架激活每个注册的IHostedService服务，并通过调用StartAsync方法来启动它们。当服务承载应用程序关闭的时候，作为服务宿主的IHost对象会被关闭，由它承载的每个IHostedService服务对象的StopAsync方法也随之被调用。

  1. public interface IHostedService
  2. {
  3.     Task StartAsync(CancellationToken cancellationToken);
  4.     Task StopAsync(CancellationToken cancellationToken);
  5. }

承载系统无缝集成了.NET Core的依赖注入框架，在服务承载过程中所需的依赖服务，包括承载服务自身和它所依赖的服务均由此框架提供，承载服务注册的本质就是将对应的IHostedService实现类型或者实例注册到依赖注入框架中。由于承载服务大都需要长时间运行直到应用被关闭，所以针对承载服务的注册一般采用Singleton生命周期模式。承载系统为承载服务的注册定义了如下这个AddHostedService<THostedService>扩展方法。由于该方法通过调用TryAddEnumerable扩展方法来注册服务，所以不用担心服务重复注册的问题。

  1. public static class ServiceCollectionHostedServiceExtensions
  2. {
  3.     public static IServiceCollection AddHostedService<THostedService>(this IServiceCollection services) where THostedService: class, IHostedService
  4.     {
  5.         services.TryAddEnumerable(ServiceDescriptor.Singleton<IHostedService, THostedService>());
  6.         return services;
  7.     }
  8. }

二、IHost

通过IHostedService接口表示的承载服务最终被承载于通过IHost接口表示的宿主上。一般来说，一个服务承载应用在整个生命周期内只会创建一个IHost对象，我们启动和关闭应用程序本质上就是启动和关闭作为宿主的IHost对象。如下面的代码片段所示，IHost接口派生于IDisposable接口，所以当它在关闭之后，应用程序还会调用其Dispose方法作一些额外的资源释放工作。IHost接口的Services属性返回作为依赖注入容器的IServiceProvider对象，该对象提供了服务承载过程中所需的服务实例，其中就包括需要承载的IHostedService服务。定义在IHost接口中的StartAsync和StopAsync方法完成了针对服务宿主的启动和关闭。

  1. public interface IHost : IDisposable
  2. {
  3.     IServiceProvider Services { get; }
  4.     Task StartAsync(CancellationToken cancellationToken = default);
  5.     Task StopAsync(CancellationToken cancellationToken = default);
  6. }

三、应用生命周期

在前面演示的实例中，在利用HostBuilder对象构建出IHost对象之后，我们并没有调用其StartAsync方法启动它，而是另一个名为Run的扩展方法。Run方法涉及到服务承载应用生命周期的管理，如果想了解该方法的本质，就得先来认识一个名为IHostApplicationLifetime的接口。顾名思义，IHostApplicationLifetime接口体现了服务承载应用程序的生命周期。如下面的代码片段所示，该接口除了提供了三个CancellationToken类型的属性来检测应用何时开启与关闭之外，还提供了一个StopApplication来关闭应用程序。

  1. public interface IHostApplicationLifetime
  2. {
  3.     CancellationToken ApplicationStarted { get; }
  4.     CancellationToken ApplicationStopping { get; }
  5.     CancellationToken ApplicationStopped { get; }
  6.  
  7.     void StopApplication();
  8. }

如下所示的ApplicationLifetime类型是对IHostApplicationLifetime接口的默认实现。我们可以看到它实现的三个属性返回的CancellationToken对象来源于三个对应的CancellationTokenSource对象，后者对应着三个不同的方法（NotifyStarted、StopApplication和NotifyStopped）。我们可以利用IHostApplicationLifetime服务的三个属性提供的CancellationToken对象得到关于应用被启动和关闭通知，这些通知最初就是由这三个对应的方法发出来的。

  1. public class ApplicationLifetime : IHostApplicationLifetime
  2. {
  3.     private readonly ILogger<ApplicationLifetime> _logger;
  4.     private readonly CancellationTokenSource _startedSource;
  5.     private readonly CancellationTokenSource _stoppedSource;
  6.     private readonly CancellationTokenSource _stoppingSource;
  7.  
  8.     public ApplicationLifetime(ILogger<ApplicationLifetime> logger)
  9.     {
  10.         _startedSource = new CancellationTokenSource();
  11.         _stoppedSource = new CancellationTokenSource();
  12.         _stoppingSource = new CancellationTokenSource();
  13.         _logger = logger;
  14.     }
  15.  
  16.     private void ExecuteHandlers(CancellationTokenSource cancel)
  17.     {
  18.         if (!cancel.IsCancellationRequested)
  19.         {
  20.             cancel.Cancel(false);
  21.         }
  22.     }
  23.  
  24.     public void NotifyStarted()
  25.     {
  26.         try
  27.         {
  28.             this.ExecuteHandlers(this._startedSource);
  29.         }
  30.         catch (Exception exception)
  31.         {
  32.             _logger.ApplicationError(6, "An error occurred starting the application",exception);
  33.         }
  34.     }
  35.  
  36.     public void NotifyStopped()
  37.     {
  38.         try
  39.         {
  40.             ExecuteHandlers(this._stoppedSource);
  41.         }
  42.         catch (Exception exception)
  43.         {
  44.             _logger.ApplicationError(8, "An error occurred stopping the application",exception);
  45.         }
  46.     }
  47.  
  48.     public void StopApplication()
  49.     {
  50.         CancellationTokenSource source = this._stoppingSource;
  51.         lock (source)
  52.         {
  53.             try
  54.             {
  55.                 ExecuteHandlers(this._stoppingSource);
  56.             }
  57.             catch (Exception exception)
  58.             {
  59.                 _logger.ApplicationError(7, "An error occurred stopping the application", exception);
  60.             }
  61.         }
  62.     }
  63.  
  64.     public CancellationToken ApplicationStarted => _startedSource.Token;
  65.     public CancellationToken ApplicationStopped => _stoppedSource.Token;
  66.     public CancellationToken ApplicationStopping => _stoppingSource.Token;
  67. }

四、利用IHostApplicationLifetime关闭应用

我们接下来通过一个简单的实例来演示如何利用IHostApplicationLifetime服务来关闭整个承载应用程序。我们在一个控制台应用程序中定义了如下这个承载服务FakeHostedService。在FakeHostedService类型的构造函数中，我们注入了IHostApplicationLifetime服务。在得到其三个属性返回的CancellationToken对象之后，我们在它们上面分别注册了一个回调，回调操作通过在控制台上输出相应的文字使我们可以知道应用程序何时被启动和关闭。

  1. public sealed class FakeHostedService : IHostedService
  2. {
  3.     private readonly IHostApplicationLifetime _lifetime;
  4.     private IDisposable _tokenSource;
  5.  
  6.     public FakeHostedService(IHostApplicationLifetime lifetime)
  7.     {
  8.         _lifetime = lifetime;
  9.         _lifetime.ApplicationStarted.Register(() => Console.WriteLine("[{0}]Application started", DateTimeOffset.Now));
  10.         _lifetime.ApplicationStopping.Register(() => Console.WriteLine("[{0}]Application is stopping.", DateTimeOffset.Now));
  11.         _lifetime.ApplicationStopped.Register(() => Console.WriteLine("[{0}]Application stopped.", DateTimeOffset.Now));
  12.     }
  13.  
  14.     public Task StartAsync(CancellationToken cancellationToken)
  15.     {
  16.         _tokenSource = new CancellationTokenSource(TimeSpan.FromSeconds(5)).Token.Register(_lifetime.StopApplication);
  17.         return Task.CompletedTask;
  18.     }
  19.  
  20.     public Task StopAsync(CancellationToken cancellationToken)
  21.     {
  22.         _tokenSource?.Dispose();
  23.         return Task.CompletedTask;
  24.     }
  25. }

在实现的StartAsync方法中，我们采用如上的方式在5秒之后调用IHostApplicationLifetime服务的StopApplication方法来关闭整个应用程序。这个FakeHostedService服务最后采用如下的方式承载于当前应用程序中。

  1. class Program
  2. {
  3.     static void Main()
  4.     {
  5.         new HostBuilder()
  6.             .ConfigureServices(svcs => svcs.AddHostedService<FakeHostedService>())
  7.             .Build()
  8.             .Run();
  9.     }
  10. }

该程序运行之后会在控制台上输出如下图所示的结果，从三条消息产生的时间间隔我们可以确定当前应用程序正是承载FakeHostedService通过调用IHostApplicationLifetime服务的StopApplication方法关闭的。（源代码从这里下载）

10-8

五、Run扩展方法

如果我们调用IHost对象的扩展方法Run，它会在内部调用StartAsync方法，接下来它会持续等待下去直到接收到应用被关闭的通知。当IHost对象对象利用IHostApplicationLifetime服务接收到关于应用关闭的通知后，它会调用自身的StopAsync方法，针对Run方法的调用此时才会返回。启动IHost对象直到应用关闭这一实现体现在如下这个WaitForShutdownAsync扩展方法上。

  1. public static class HostingAbstractionsHostExtensions
  2. {
  3.     public static async Task WaitForShutdownAsync(this IHost host, CancellationToken token = default)
  4.     {
  5.         var applicationLifetime = host.Services.GetService<IHostApplicationLifetime>();
  6.         token.Register(state => ((IHostApplicationLifetime)state).StopApplication(), applicationLifetime);
  7.  
  8.         var waitForStop = new TaskCompletionSource<object>(TaskCreationOptions.RunContinuationsAsynchronously);
  9.         applicationLifetime.ApplicationStopping.Register(state =>
  10.         {
  11.             var tcs = (TaskCompletionSource<object>)state;
  12.             tcs.TrySetResult(null);
  13.         }, waitForStop);
  14.  
  15.         await waitForStop.Task;
  16.         await host.StopAsync();
  17.     }
  18. }

如下所示的WaitForShutdown方法是上面这个WaitForShutdownAsync方法的同步版本。同步的Run方法和异步的RunAsync方法的实现也体现在下面的代码片段中。除此之外，下面的代码片段还提供了Start和StopAsync这两个扩展方法，前者可以视为StartAsync方法的同步版本，后者可以在关闭IHost对象的时候指定一个超时时限。

  1. public static class HostingAbstractionsHostExtensions
  2. {
  3.     public static void WaitForShutdown(this IHost host) => host.WaitForShutdownAsync().GetAwaiter().GetResult();
  4.     public static void Run(this IHost host) => host.RunAsync().GetAwaiter().GetResult();
  5.     public static async Task RunAsync(this IHost host, CancellationToken token = default)
  6.     {
  7.         try
  8.         {
  9.             await host.StartAsync(token);
  10.             await host.WaitForShutdownAsync(token);
  11.         }
  12.         finally
  13.         {
  14.             host.Dispose();
  15.         }
  16.     }
  17.     public static void Start(this IHost host) => host.StartAsync().GetAwaiter().GetResult();
  18.     public static Task StopAsync(this IHost host, TimeSpan timeout) => host.StopAsync(new CancellationTokenSource(timeout).Token);
  19. }

服务承载系统[3]: 总体设计[上篇] - 图4

作者：蒋金楠微信公众账号：大内老A微博：www.weibo.com/artech如果你想及时得到个人撰写文章以及著作的消息推送，或者想看看个人推荐的技术资料，可以扫描左边二维码（或者长按识别二维码）关注个人公众号）。本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利。

原文：https://www.cnblogs.com/artech/p/inside-asp-net-core-09-03.html