zoukankan html css js c++ java

利用.NET Core中的Worker Service，来创建windows服务或linux守护程序

导航

开始创建worker service 项目
Program.cs
Worker.cs
依赖注入（DI）
重写BackgroundService类的StartAsync、ExecuteAsync、StopAsync方法
不要让线程阻塞worker类中重写的StartAsync、ExecuteAsync、StopAsync方法
在Worker Service中运行多个Worker类
部署为Windows服务运行
部署作为Linux守护程序运行
参考文献

.NET Core 3.0新增了Worker Service的新项目模板，可以编写长时间运行的后台服务，并且能轻松的部署成windows服务或linux守护程序。如果安装的vs2019是中文版本，Worker Service的项目名称就变成了辅助角色服务。Worker Service 咱也不知道怎么翻译成了这个名称，咱也不敢乱翻译，下文就保持原名称。。。，本文将会演示如何创建一个Worker Service项目，并且部署为windows服务或linux守护程序运行；

开始创建worker service 项目

创建新项目——》选择 Worker Service（辅助角色服务）

取一个项目名称：DemoWorkerService

项目创建成功之后，您会看到创建了两个类：Program和Worker。

Program.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;

namespace DemoWorkerService
{
    public class Program
    {
        public static void Main(string[] args)
        {
            CreateHostBuilder(args).Build().Run();
        }

        public static IHostBuilder CreateHostBuilder(string[] args) =>
            Host.CreateDefaultBuilder(args)
                .ConfigureServices((hostContext, services) =>
                {
                    services.AddHostedService<Worker>();
                });
    }
}

Program类跟ASP.NET Core Web应用程序非常类似，不同之处没有了startup类，并且把worker服务添加到DI container中。

Worker.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;

namespace DemoWorkerService
{
    public class Worker : BackgroundService
    {
        private readonly ILogger<Worker> _logger;

        public Worker(ILogger<Worker> logger)
        {
            _logger = logger;
        }

        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
        {
            while (!stoppingToken.IsCancellationRequested)
            {
                _logger.LogInformation("Worker running at: {time}", DateTimeOffset.Now);
                await Task.Delay(1000, stoppingToken);
            }
        }
    }
}

worker只是一个简单的类，它继承自BackgroundService ，而后者又实现IHostedService接口。

依赖注入（DI）

我们可以在Program类中的ConfigureServices方法中，配置Worker类构造函数要用到的依赖注入关系，假如我们现在有IContainer接口和MyContainer类，它们是一组依赖注入关系：

public interface IContainer
{
    string ContainerName
    {
        get;
        set;
    }
}

public class MyContainer : IContainer
{
    protected string containerName = "Custom my container";

    public string ContainerName
    {
        get
        {
            return containerName;
        }
        set
        {
            containerName = value;
        }
    }
}

我们可以在Program类中的ConfigureServices方法中，使用services参数（该参数是IServiceCollection接口的对象）来配置IContainer接口和MyContainer类的依赖注入关系：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using DemoWorkerService.Model;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;

namespace DemoWorkerService
{
    public class Program
    {
        public static void Main(string[] args)
        {
            CreateHostBuilder(args).Build().Run();
        }

        public static IHostBuilder CreateHostBuilder(string[] args) =>
            Host.CreateDefaultBuilder(args)
                .ConfigureServices((hostContext, services) =>
                {
                    services.AddTransient<IContainer, MyContainer>();//配置IContainer接口和MyContainer类的依赖注入关系
                    services.AddHostedService<Worker>();
                });
    }
}

然后在Worker类的构造函数中，Worker Service就会使用DI（依赖注入）自动注入IContainer类型的参数：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using DemoWorkerService.Model;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;

namespace DemoWorkerService
{
    public class Worker : BackgroundService
    {
        private readonly ILogger<Worker> _logger;
        private readonly IContainer _container;

        //Worker Service会自动依赖注入Worker构造函数的IContainer container参数
        public Worker(ILogger<Worker> logger, IContainer container)
        {
            _logger = logger;
            _container = container;
        }

        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
        {
            while (!stoppingToken.IsCancellationRequested)
            {
                _logger.LogInformation("Worker running at: {time}", DateTimeOffset.Now);
                await Task.Delay(1000, stoppingToken);
            }
        }
    }
}

注意上面worker类的构造函数中，使用了.NET Core自带的日志组件接口对象ILogger，它也是通过DI（依赖注入）注入到worker类的构造函数中的，和ASP.NET Core中Controller的构造函数类似（关于ILogger，可以查看这里了解），我们也可以不用日志组件，给worker类定义无参的默认构造函数。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.Extensions.Hosting;

namespace DemoWorkerService
{
    public class Worker : BackgroundService
    {
        public Worker()
        {
        }

        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
        {
            while (!stoppingToken.IsCancellationRequested)
            {
                await Task.Delay(1000, stoppingToken);
            }
        }
    }
}

重写BackgroundService类的StartAsync、ExecuteAsync、StopAsync方法

我们可以通过 override ExecuteAsync 方法来完成自己要做的事情，该方法实际上属于BackgroundService类，我们是在worker类中重写（override）了它，这个方法中我们就可以调用在windows服务或linux守护程序中要处理的逻辑，原则上来说这个逻辑应该是在一个死循环中，并且通过ExecuteAsync方法传入的CancellationToken参数对象，来判断是否应该结束循环，例如如果windows服务被停止，那么参数中CancellationToken类的IsCancellationRequested属性会返回true，那么我们应该停止ExecuteAsync方法中的循环，来结束整个windows服务：

//重写BackgroundService.ExecuteAsync方法，封装windows服务或linux守护程序中的处理逻辑
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
    //如果服务被停止，那么下面的IsCancellationRequested会返回true，我们就应该结束循环
    while (!stoppingToken.IsCancellationRequested)
    {
        //模拟服务中的处理逻辑，这里我们仅输出一条日志，并且等待1秒钟时间
        _logger.LogInformation("Worker running at: {time}", DateTimeOffset.Now);
        await Task.Delay(1000, stoppingToken);
    }
}

此外我们也可以在worker类中重写BackgroundService.StartAsync方法和BackgroundService.StopAsync方法（注意重写时，不要忘记在worker类中调用base.StartAsync和base.StopAsync，因为BackgroundService类的StartAsync和StopAsync会执行一些Worker Service的核心代码），在开始和结束Worker Service服务（例如，开始和停止windows服务）的时候，来执行一些处理逻辑，本例中我们分别输出了一条日志：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;

namespace DemoWorkerService
{
    public class Worker : BackgroundService
    {
        private readonly ILogger<Worker> _logger;

        public Worker(ILogger<Worker> logger)
        {
            _logger = logger;
        }

        //重写BackgroundService.StartAsync方法，在开始服务的时候，执行一些处理逻辑，这里我们仅输出一条日志
        public override async Task StartAsync(CancellationToken cancellationToken)
        {
            _logger.LogInformation("Worker starting at: {time}", DateTimeOffset.Now);

            await base.StartAsync(cancellationToken);
        }

        //重写BackgroundService.ExecuteAsync方法，封装windows服务或linux守护程序中的处理逻辑
        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
        {
            //如果服务被停止，那么下面的IsCancellationRequested会返回true，我们就应该结束循环
            while (!stoppingToken.IsCancellationRequested)
            {
                //模拟服务中的处理逻辑，这里我们仅输出一条日志，并且等待1秒钟时间
                _logger.LogInformation("Worker running at: {time}", DateTimeOffset.Now);
                await Task.Delay(1000, stoppingToken);
            }
        }

        //重写BackgroundService.StopAsync方法，在结束服务的时候，执行一些处理逻辑，这里我们仅输出一条日志
        public override async Task StopAsync(CancellationToken cancellationToken)
        {
            _logger.LogInformation("Worker stopping at: {time}", DateTimeOffset.Now);

            await base.StopAsync(cancellationToken);
        }
    }
}

由于BackgroundService类的StartAsync、ExecuteAsync、StopAsync方法返回的都是Task类型，所以如同上面代码所示，我们可以使用async和await关键字将它们重写为异步函数，来提高程序的性能。现在我们在Visual Studio中直接运行上面的代码，结果如下所示，每隔1秒，循环打印运行的时间：

其中我用三个红色框，将worker类中重写StartAsync、ExecuteAsync、StopAsync方法的输出结果标识了出来，在Visual Studio中运行Worker Service项目时，可以在启动的控制台中使用快捷键"Ctrl+C"来停止Worker Service的运行（相当于停止windows服务或linux守护程序），所以这样我们可以在上面的结果中看到StartAsync、ExecuteAsync、StopAsync三个方法都被执行了，并且都输出了日志。

其实我们可以看到Worker Service项目从本质上来说就是一个控制台项目，只不过当它被部署为windows服务或linux守护程序后，不会显示控制台窗口。

所以实际上在Visual Studio中进行调试的时候，完全可以用Console.WriteLine等控制台方法来替代ILogger接口的日志输出方法：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;

namespace DemoWorkerService
{
    public class Worker : BackgroundService
    {
        public Worker()
        {
        }

        //重写BackgroundService.StartAsync方法，在开始服务的时候，执行一些处理逻辑，这里我们仅输出一条日志
        public override async Task StartAsync(CancellationToken cancellationToken)
        {
            Console.WriteLine("Worker starting at: {0}", DateTimeOffset.Now);

            await base.StartAsync(cancellationToken);
        }

        //重写BackgroundService.ExecuteAsync方法，封装windows服务或linux守护程序中的处理逻辑
        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
        {
            //如果服务被停止，那么下面的IsCancellationRequested会返回true，我们就应该结束循环
            while (!stoppingToken.IsCancellationRequested)
            {
                //模拟服务中的处理逻辑，这里我们仅输出一条日志，并且等待1秒钟时间
                Console.WriteLine("Worker running at: {0}", DateTimeOffset.Now);
                await Task.Delay(1000, stoppingToken);
            }
        }

        //重写BackgroundService.StopAsync方法，在结束服务的时候，执行一些处理逻辑，这里我们仅输出一条日志
        public override async Task StopAsync(CancellationToken cancellationToken)
        {
            Console.WriteLine("Worker stopping at: {0}", DateTimeOffset.Now);

            await base.StopAsync(cancellationToken);
        }
    }
}

其效果和ILogger接口的日志输出方法类似：

不过由于ILogger接口的日志输出方法，也可以输出信息到控制台上，所以我还是更推荐使用ILogger接口来输出调试信息，毕竟它更适合做日志记录。

不要让线程阻塞worker类中重写的StartAsync、ExecuteAsync、StopAsync方法

注意不要让你的代码阻塞worker类中重写的StartAsync、ExecuteAsync、StopAsync方法。

因为StartAsync方法负责启动Worker Service，如果调用StartAsync方法的线程被一直阻塞了，那么Worker Service的启动就一直完成不了。

同理StopAsync方法负责结束Worker Service，如果调用StopAsync方法的线程被一直阻塞了，那么Worker Service的结束就一直完成不了。

这里主要说明下为什么ExecuteAsync方法不能被阻塞，我们尝试把本例中的ExecuteAsync方法改为如下代码：

protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
    while (!stoppingToken.IsCancellationRequested)
    {
        _logger.LogInformation("Worker running at: {time}", DateTimeOffset.Now);
        Thread.Sleep(1000);//使用Thread.Sleep进行同步等待，调用ExecuteAsync方法的线程会一直执行这里的循环，被不停地被阻塞
    }

    await Task.CompletedTask;
}

我们将ExecuteAsync方法中的异步等待方法Task.Delay，改为了同步等待方法Thread.Sleep（关于Thread.Sleep和Task.Delay有什么不同，请查看这里）。由于Thread.Sleep方法是将执行线程通过阻塞的方式来进行等待，所以现在调用ExecuteAsync方法的线程会一直执行ExecuteAsync方法中的循环，被不停地被阻塞，除非ExecuteAsync方法中的循环结束，那么调用ExecuteAsync方法的线程会被一直卡在ExecuteAsync方法中。现在我们在Visual Studio中运行Worker Service，执行结果如下：

我们可以看到当我们在控制台中使用快捷键"Ctrl+C"试图停止Worker Service后（上图红色框中输出的日志），ExecuteAsync方法中的循环还是在不停地运行来输出日志，这说明ExecuteAsync方法的CancellationToken参数的IsCancellationRequested属性还是返回的false，所以这就是问题所在，如果我们直接用调用ExecuteAsync方法的线程去做循环，来执行windows服务或linux守护程序的处理逻辑，会导致Worker Service无法被正常停止，因为ExecuteAsync方法的CancellationToken参数没有被更新。

所以，那些很耗时并且要循环处理的 windows服务或linux守护程序的处理逻辑，应该要放到另外的线程中去执行，而不是由调用ExecuteAsync方法的线程去执行。

所以假设我们现在有三个 windows服务或linux守护程序的逻辑现在要被处理，我们可以将它们放到三个新的线程中去执行，如下代码所示：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;

namespace DemoWorkerService
{
    public class Worker : BackgroundService
    {
        private readonly ILogger<Worker> _logger;

        public Worker(ILogger<Worker> logger)
        {
            _logger = logger;
        }

        //重写BackgroundService.StartAsync方法，在开始服务的时候，执行一些处理逻辑，这里我们仅输出一条日志
        public override async Task StartAsync(CancellationToken cancellationToken)
        {
            _logger.LogInformation("Worker starting at: {time}", DateTimeOffset.Now);

            await base.StartAsync(cancellationToken);
        }

        //第一个 windows服务或linux守护程序 的处理逻辑，由RunTaskOne方法内部启动的Task任务线程进行处理，同样可以从参数CancellationToken stoppingToken中的IsCancellationRequested属性，得知Worker Service服务是否已经被停止
        protected Task RunTaskOne(CancellationToken stoppingToken)
        {
            return Task.Run(() =>
            {
                //如果服务被停止，那么下面的IsCancellationRequested会返回true，我们就应该结束循环
                while (!stoppingToken.IsCancellationRequested)
                {
                    _logger.LogInformation("RunTaskOne running at: {time}", DateTimeOffset.Now);
                    Thread.Sleep(1000);
                }
            }, stoppingToken);
        }

        //第二个 windows服务或linux守护程序 的处理逻辑，由RunTaskTwo方法内部启动的Task任务线程进行处理，同样可以从参数CancellationToken stoppingToken中的IsCancellationRequested属性，得知Worker Service服务是否已经被停止
        protected Task RunTaskTwo(CancellationToken stoppingToken)
        {
            return Task.Run(() =>
            {
                //如果服务被停止，那么下面的IsCancellationRequested会返回true，我们就应该结束循环
                while (!stoppingToken.IsCancellationRequested)
                {
                    _logger.LogInformation("RunTaskTwo running at: {time}", DateTimeOffset.Now);
                    Thread.Sleep(1000);
                }
            }, stoppingToken);
        }

        //第三个 windows服务或linux守护程序 的处理逻辑，由RunTaskThree方法内部启动的Task任务线程进行处理，同样可以从参数CancellationToken stoppingToken中的IsCancellationRequested属性，得知Worker Service服务是否已经被停止
        protected Task RunTaskThree(CancellationToken stoppingToken)
        {
            return Task.Run(() =>
            {
                //如果服务被停止，那么下面的IsCancellationRequested会返回true，我们就应该结束循环
                while (!stoppingToken.IsCancellationRequested)
                {
                    _logger.LogInformation("RunTaskThree running at: {time}", DateTimeOffset.Now);
                    Thread.Sleep(1000);
                }
            }, stoppingToken);
        }

        //重写BackgroundService.ExecuteAsync方法，封装windows服务或linux守护程序中的处理逻辑
        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
        {
            try
            {
                Task taskOne = RunTaskOne(stoppingToken);
                Task taskTwo = RunTaskTwo(stoppingToken);
                Task taskThree = RunTaskThree(stoppingToken);

                await Task.WhenAll(taskOne, taskTwo, taskThree);//使用await关键字，异步等待RunTaskOne、RunTaskTwo、RunTaskThree方法返回的三个Task对象完成，这样调用ExecuteAsync方法的线程会立即返回，不会卡在这里被阻塞
            }
            catch (Exception ex)
            {
                //RunTaskOne、RunTaskTwo、RunTaskThree方法中，异常捕获后的处理逻辑，这里我们仅输出一条日志
                _logger.LogError(ex.Message);
            }
            finally
            {
                //Worker Service服务停止后，如果有需要收尾的逻辑，可以写在这里
            }
        }

        //重写BackgroundService.StopAsync方法，在结束服务的时候，执行一些处理逻辑，这里我们仅输出一条日志
        public override async Task StopAsync(CancellationToken cancellationToken)
        {
            _logger.LogInformation("Worker stopping at: {time}", DateTimeOffset.Now);

            await base.StopAsync(cancellationToken);
        }
    }
}

所以现在调用ExecuteAsync方法的线程就不会被阻塞了，在Visual Studio中运行Worker Service，执行结果如下：

可以看到这次，当我们在控制台中使用快捷键"Ctrl+C"试图停止Worker Service后（上图红色框中输出的日志），ExecuteAsync方法就立即停止运行了，所以这里再次强调千万不要去阻塞调用ExecuteAsync方法的线程！

另外上面代码中，我们在worker类重写的ExecuteAsync方法中放了一个finally代码块，这个代码块可以用来执行一些Worker Service服务停止后（例如停止 windows服务或linux守护程序时）的一些收尾代码逻辑（例如关闭数据库连接、释放资源等），我更倾向于使用ExecuteAsync方法中的finally代码块来做Worker Service的收尾工作，而不是在worker类重写的StopAsync方法中来做收尾工作（从BackgroundService的源代码，我们可以看出worker类的StopAsync方法是有可能比ExecuteAsync方法先完成的，所以Worker Service的收尾工作应该放到ExecuteAsync方法中的finally代码块），因为ExecuteAsync方法中的finally代码块，肯定是在RunTaskOne、RunTaskTwo、RunTaskThree方法返回的三个Task对象执行完毕后才执行的。

StopAsync方法

这里再说下BackgroundService类的StopAsync方法，这个方法官方的解释是：当Worker Service进行graceful shutdown的时候会被执行，这个graceful shutdown有一些限制条件，我在windows操作系统下进行了测试，当在windows服务管理列表中停止或重启服务时，BackgroundService类的StopAsync方法是会被执行的，同时上面代码ExecuteAsync方法中的finally代码块也会被执行，但是当我在windows操作系统中，直接点关机或重启时，BackgroundService类的StopAsync方法没有被执行到，同时上面代码ExecuteAsync方法中的finally代码块也没有被执行。。。这说明BackgroundService类的StopAsync方法，并不是在Worker Service服务停止的时候肯定会被执行，例如关机或重启就不会被执行，所以如果我们把很重要的Worker Service服务结束逻辑放到StopAsync方法中，是有安全隐患的。

目前从GitHub上得知这是.NET Core 3.0的一个Bug，微软会在.NET 5.0中修复这个问题，详情查看这里。

在Worker Service中运行多个Worker类

在前面的例子中，可以看到我们在一个Worker类中定义了三个方法RunTaskOne、RunTaskTwo、RunTaskThree，来执行三个 windows服务或linux守护程序的逻辑。

其实我们还可以在一个Worker Service项目中，定义和执行多个Worker类，而不是把所有的代码逻辑都放在一个Worker类中。

首先我们定义第一个Worker类WorkerOne：

using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace DemoWorkerService
{
    public class WorkerOne : BackgroundService
    {
        private readonly ILogger<Worker> _logger;

        public WorkerOne(ILogger<Worker> logger)
        {
            _logger = logger;
        }

        //重写BackgroundService.StartAsync方法，在开始服务的时候，执行一些处理逻辑，这里我们仅输出一条日志
        public override async Task StartAsync(CancellationToken cancellationToken)
        {
            _logger.LogInformation("WorkerOne starting at: {time}", DateTimeOffset.Now);

            await base.StartAsync(cancellationToken);
        }

        //重写BackgroundService.ExecuteAsync方法，封装windows服务或linux守护程序中的处理逻辑
        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
        {
            //如果服务被停止，那么下面的IsCancellationRequested会返回true，我们就应该结束循环
            while (!stoppingToken.IsCancellationRequested)
            {
                //模拟服务中的处理逻辑，这里我们仅输出一条日志，并且等待1秒钟时间
                _logger.LogInformation("WorkerOne running at: {time}", DateTimeOffset.Now);
                await Task.Delay(1000, stoppingToken);
            }
        }

        //重写BackgroundService.StopAsync方法，在结束服务的时候，执行一些处理逻辑，这里我们仅输出一条日志
        public override async Task StopAsync(CancellationToken cancellationToken)
        {
            _logger.LogInformation("WorkerOne stopping at: {time}", DateTimeOffset.Now);

            await base.StopAsync(cancellationToken);
        }
    }
}

接着我们定义第二个Worker类WorkerTwo：

using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace DemoWorkerService
{
    public class WorkerTwo : BackgroundService
    {
        private readonly ILogger<Worker> _logger;

        public WorkerTwo(ILogger<Worker> logger)
        {
            _logger = logger;
        }

        //重写BackgroundService.StartAsync方法，在开始服务的时候，执行一些处理逻辑，这里我们仅输出一条日志
        public override async Task StartAsync(CancellationToken cancellationToken)
        {
            _logger.LogInformation("WorkerTwo starting at: {time}", DateTimeOffset.Now);

            await base.StartAsync(cancellationToken);
        }

        //重写BackgroundService.ExecuteAsync方法，封装windows服务或linux守护程序中的处理逻辑
        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
        {
            //如果服务被停止，那么下面的IsCancellationRequested会返回true，我们就应该结束循环
            while (!stoppingToken.IsCancellationRequested)
            {
                //模拟服务中的处理逻辑，这里我们仅输出一条日志，并且等待1秒钟时间
                _logger.LogInformation("WorkerTwo running at: {time}", DateTimeOffset.Now);
                await Task.Delay(1000, stoppingToken);
            }
        }

        //重写BackgroundService.StopAsync方法，在结束服务的时候，执行一些处理逻辑，这里我们仅输出一条日志
        public override async Task StopAsync(CancellationToken cancellationToken)
        {
            _logger.LogInformation("WorkerTwo stopping at: {time}", DateTimeOffset.Now);

            await base.StopAsync(cancellationToken);
        }
    }
}

然后我们在Program类中，将WorkerOne和WorkerTwo服务添加到DI container中：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;

namespace DemoWorkerService
{
    public class Program
    {
        public static void Main(string[] args)
        {
            CreateHostBuilder(args).Build().Run();
        }

        public static IHostBuilder CreateHostBuilder(string[] args) =>
            Host.CreateDefaultBuilder(args)
                .ConfigureServices((hostContext, services) =>
                {
                    services.AddHostedService<WorkerOne>();
                    services.AddHostedService<WorkerTwo>();
                });
    }
}

然后在Visual Studio中运行Worker Service，执行结果如下：

在控制台中使用快捷键"Ctrl+C"来停止Worker Service的运行后，我用三个红色框，将WorkerOne和WorkerTwo类中重写StartAsync、ExecuteAsync、StopAsync方法的输出结果标识了出来，可以看到WorkerOne和WorkerTwo类都被执行了，并且都输出了日志信息。

部署为Windows服务运行

1.在项目中添加nuget包：Microsoft.Extensions.Hosting.WindowsServices

2.然后在program.cs内部，将UseWindowsService()添加到CreateHostBuilder

public static IHostBuilder CreateHostBuilder(string[] args) =>
    Host.CreateDefaultBuilder(args)
        .UseWindowsService()
        .ConfigureServices((hostContext, services) =>
        {
            services.AddHostedService<Worker>();
        });

注意，在非 Windows 平台上调用 UseWindowsService 方法也是不会报错的，非 Windows 平台会忽略此调用。

3.执行一下命令发布项目

dotnet publish  -c Release -o C:WorkerPub

在CMD中执行：

当然，也可以在Visual Studio中用项目自身的发布向导来将Worker Service项目发布到文件夹"C:WorkerPub"中：

默认情况下Worker Service项目会被发布为一个exe文件：

4.然后使用sc.exe工具来管理服务，输入一下命令创建为windows服务，这里我们将DemoWorkerService.exe创建为了名为NETCoreDemoWorkerService的windows服务：

sc.exe create NETCoreDemoWorkerService binPath=C:WorkerPubDemoWorkerService.exe

在CMD中执行，注意这里要用管理员模式（Run as administrator）启动CMD：

查看服务状态使用一下命令：

sc.exe query NETCoreDemoWorkerService

在CMD中执行（Run as administrator）：

启动命令：

sc.exe start NETCoreDemoWorkerService

在CMD中执行（Run as administrator）：

在windows服务列表查看，NETCoreDemoWorkerService已安装成功：

停用、删除命令：

sc.exe stop NETCoreDemoWorkerService
sc.exe delete NETCoreDemoWorkerService

在CMD中执行（Run as administrator）：

部署作为Linux守护程序运行

部署linux守护程序也是很方便的执行一下两个步骤即可：

添加Microsoft.Extensions.Hosting.Systemd NuGet包到项目中，并告诉你的新Worker，其生命周期由systemd管理！
将UseSystemd()添加到主机构建器中

public static IHostBuilder CreateHostBuilder(string[] args) =>
    Host.CreateDefaultBuilder(args)
        .UseSystemd()
        .ConfigureServices((hostContext, services) =>
        {
            services.AddHostedService<Worker>();
        });

同样，在 Windows 平台上调用 UseSystemd 方法也是不会报错的，Windows 平台会忽略此调用。

参考文献：

.NET Core创建Worker Services

Worker Service in ASP .NET Core

查看全文

相关阅读:
Qt Installer Framework翻译(3-4)
Qt Installer Framework翻译(3-3)
Qt Installer Framework翻译(3-2)
Qt Installer Framework翻译(3-1)
Qt Installer Framework翻译(3-0)
Qt Installer Framework翻译(0)
Qt Installer Framework翻译(2)
Qt Installer Framework翻译(1)
野生前端的数据结构基础练习（8）——图
 野生前端的数据结构基础练习（7）——二叉树

原文地址：https://www.cnblogs.com/OpenCoder/p/12191164.html