.NET CORE WORKER服务作为Windows服务致电PostAsync之后不停止

Question

我有一个工作人员服务部署为Windows服务，并且在停止Windows服务时遇到问题，它显示了从日志中停止的，但是当我登录到服务器时，它仍然说运行。

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

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

  public override Task StartAsync(CancellationToken cancellationToken)
  {
    _logger.LogInformation("Windows Service is Starting....   ");
    return base.StartAsync(cancellationToken);
  }
  protected override async Task ExecuteAsync(CancellationToken stoppingToken)
  {
    //initial value coming as false
    _logger.LogInformation(string.Format("Cancellation token initial value : {0}", stoppingToken.IsCancellationRequested));

        while (!stoppingToken.IsCancellationRequested)
        {
           try
           {
              _logger.LogInformation("Starting the Process .....");
               
              //Dummy task used here, so it can cancel token.
              await Task.Delay(1000);       
         
              //Deliberately failing in the string.Format to test windows service stopping
              string.Format("Failing with exception here : {1}", "Test");
            }
           
            catch (Exception ex)
            {
              _logger.LogError(ex, ex.Message);
               var canclSrc = new CancellationTokenSource();
               canclSrc.Cancel();
               await StopAsync(canclSrc.Token);
                   
               //Cancellation token here is coming as true..
               _logger.LogInformation(string.Format("Cancellation token value : {0}", stoppingToken.IsCancellationRequested));
               _logger.LogInformation("Windows Service is stopped..");
             }
         }
    //Windows service failed and it is logging outside the while loop.
    _logger.LogInformation("Came out of while loop as windows service stopped!");
  }

 public override Task StopAsync(CancellationToken cancellationToken)
 {
   _logger.LogInformation("Stopping Windows Service...");
   return base.StopAsync(cancellationToken);
 }

它在日志中提供了取消令牌，成功地调用了stopasync方法。

它正在显示运行，并且Windows服务被击中在我看不到的任何登录的地方。

当我登录服务器并查看Windows服务时， 即使调用了StopAsync，也不会停止服务器上。

Answer 1

等待stopAsync（canclsrc.token）;

您的背景服务不应停止。

如果您想拆除主人（即Win32服务），则应调用ihostapplicationlifetime.stopapplication （如我的博客上所述）。这样的事情：

public class Worker : BackgroundService
{
  private readonly ILogger<Worker> _logger;
  private readonly IHostApplicationLifetime _hostApplicationLifetime;

  public Worker(ILogger<Worker> logger, IHostApplicationLifetime hostApplicationLifetime) => (_logger, _hostApplicationLifetime) = (logger, hostApplicationLifetime);

  protected override async Task ExecuteAsync(CancellationToken stoppingToken)
  {
    _logger.LogInformation("Windows Service is Starting....   ");

    _logger.LogInformation(string.Format("Cancellation token initial value : {0}", stoppingToken.IsCancellationRequested));

    try
    {
      while (!stoppingToken.IsCancellationRequested)
      {
        _logger.LogInformation("Starting the Process .....");
               
        await Task.Delay(1000);       
         
        //Deliberately failing in the string.Format to test windows service stopping
        string.Format("Failing with exception here : {1}", "Test");
      }
    }
    catch (Exception ex)
    {
      _logger.LogError(ex, ex.Message);
    }
    finally
    {
      _logger.LogInformation("Windows Service is stopped..");
      _hostApplicationLifetime.StopApplication();
    }
  }
}

Answer 2

我会坚持 Microsoft's示例使用emoverition.exit（1）：

namespace App.WindowsService;

public sealed class WindowsBackgroundService : BackgroundService
{
    private readonly JokeService _jokeService;
    private readonly ILogger<WindowsBackgroundService> _logger;

    public WindowsBackgroundService(
        JokeService jokeService,
        ILogger<WindowsBackgroundService> logger) =>
        (_jokeService, _logger) = (jokeService, logger);

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        try
        {
            while (!stoppingToken.IsCancellationRequested)
            {
                string joke = _jokeService.GetJoke();
                _logger.LogWarning("{Joke}", joke);

                await Task.Delay(TimeSpan.FromMinutes(1), stoppingToken);
            }
        }
        catch (TaskCanceledException)
        {
            // When the stopping token is canceled, for example, a call made from services.msc,
            // we shouldn't exit with a non-zero exit code. In other words, this is expected...
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "{Message}", ex.Message);

            // Terminates this process and returns an exit code to the operating system.
            // This is required to avoid the 'BackgroundServiceExceptionBehavior', which
            // performs one of two scenarios:
            // 1. When set to "Ignore": will do nothing at all, errors cause zombie services.
            // 2. When set to "StopHost": will cleanly stop the host, and log errors.
            //
            // In order for the Windows Service Management system to leverage configured
            // recovery options, we need to terminate the process with a non-zero exit code.
            Environment.Exit(1);
        }
    }
}

如果您在应用程序中使用自己的取消令牌来发出重新启动的信号，则：

try
{
    // Implementation
}
catch (TaskCanceledException ex)
{
    // perhaps log debug / trace
}
catch (Exception ex)
{
    // log error
}
finally
{
    // Note that `stoppingToken.IsCancellationRequested` being true means the service was
    // manually stopped using services.msc, so returning a non-zero exit code is not desired.
    if (!stoppingToken.IsCancellationRequested)
        Environment.Exit(1);
}

：

当使用_HostApplicationLifeTime时 .stopapplication（）; Windows Service Manager在配置以重新启动错误时不会重新启动服务，因为它没有获得非零退出代码。

从我的测试中：

emoverition.exit（1）必须在backgroundService executeasync退出之前完成。

什么 从我的测试中起作用：

• 从main返回非零INT。
• Environment.exit（1）在Main停止之后。
• 取消取消令牌传递给Kestrel的RunAsync方法。
• 设置emoveruct.exitcode = 1 executeasync返回。

我还没有查看Microsoft的Dotnet运行时源，以了解为什么是这样的。

来自 https：///blog.stephencleary.com/2020/2020/06 /ServiceBase-gotcha-recovery-actions.html ：

public class MyBackgroundService : BackgroundService
{
  private readonly IHostLifetime _hostLifetime;
  public MyBackgroundService(IHostLifetime hostLifetime) =>
      _hostLifetime = hostLifetime;

  protected override Task ExecuteAsync(CancellationToken stoppingToken)
  {
    try
    {
      // Implementation
    }
    catch (Exception)
    {
      if (_hostLifetime is ServiceBase serviceLifetime)
        serviceLifetime.ExitCode = -1;
      else
        Environment.ExitCode = -1;
    }
  }
}

设置servicelifetime.exitcode = -1可能有效（我尚未对此进行测试）。但是，正如我在emoverion.exitCode = -1不起作用之前所说的。注意servicelifetime.exitcode = -1不在Windows中时抛出。

此外，上述问题是当executeasync退出时，Kestrel保持运行。

正如从同一博客指出的那样：

https：https：// blog。 stephencleary.com/2020/06/backgroundService-gotcha-application-lifetime.html

public class MyBackgroundService : BackgroundService
{
    private readonly IHostApplicationLifetime _hostApplicationLifetime;
    public MyBackgroundService(IHostApplicationLifetime hostApplicationLifetime) =>
        _hostApplicationLifetime = hostApplicationLifetime;

    protected override Task ExecuteAsync(CancellationToken stoppingToken)
    {
        try
        {
            // Implementation
        }
        finally
        {
            _hostApplicationLifetime.StopApplication();
        }
    }
}

这就是为什么我更喜欢emoverial.exit.exit（1）至少在我脱离使用Windows Services之前。