ASP.NET Core'da barındırılan hizmetlerle arka plan görevleri

Tarafından Jeow Li Huan

ASP.NET Core'da arka plan görevleri barındırılan hizmetler olarak uygulanabilir. Barındırılan hizmet, arabirimini uygulayan arka plan görev mantığına sahip bir sınıftır IHostedService . Bu makalede üç barındırılan hizmet örneği verilmiştir:

  • Zamanlayıcı üzerinde çalışan arka plan görevi.
  • Kapsamlı bir hizmeti etkinleştiren barındırılan hizmet. Kapsamı belirlenmiş hizmet bağımlılık eklemeyi (DI) kullanabilir.
  • Sıralı olarak çalışan kuyruğa alınmış arka plan görevleri.

Çalışan Hizmeti şablonu

ASP.NET Core Çalışan Hizmeti şablonu, uzun süre çalışan hizmet uygulamaları yazmak için bir başlangıç noktası sağlar. Çalışan Hizmeti şablonundan oluşturulan bir uygulama, proje dosyasında Çalışan SDK'sını belirtir:

<Project Sdk="Microsoft.NET.Sdk.Worker">

Şablonu barındırılan hizmetler uygulamasında temel olarak kullanmak için:

  1. Yeni bir proje oluşturma.
  2. Çalışan Hizmeti'ne tıklayın. İleri’yi seçin.
  3. Proje adı alanına bir proje adı girin veya varsayılan proje adını kabul edin. İleri’yi seçin.
  4. Ek bilgiler iletişim kutusunda Bir Çerçeve Seçin. Oluştur’u seçin.

Paket

Çalışan Hizmeti şablonunu temel alan bir uygulama SDK'yi Microsoft.NET.Sdk.Worker kullanır ve Microsoft.Extensions.Hosting paketine yönelik açık bir paket başvurusuna sahiptir. Örneğin, örnek uygulamanın proje dosyasına ( )BackgroundTasksSample.csproj bakın.

SDK kullanan Microsoft.NET.Sdk.Web web uygulamaları için Microsoft.Extensions.Hosting paketine paylaşılan çerçeveden örtük olarak başvurulur. Uygulamanın proje dosyasında açık bir paket başvurusu gerekli değildir.

IHostedService arabirimi

Arabirimi, IHostedService konak tarafından yönetilen nesneler için iki yöntem tanımlar:

StartAsync

StartAsync(CancellationToken), arka plan görevini başlatma mantığını içerir. StartAsync daha önce çağrılır:

StartAsync barındırılan hizmetler sıralı olarak çalıştırıldığından ve çalıştırmalar tamamlanıncaya kadar StartAsync başka hizmet başlatılmadığından, kısa süre çalışan görevlerle sınırlı olmalıdır.

StopAsync

İptal belirtecinin kapatma işleminin artık düzgün olmaması gerektiğini belirtmek için varsayılan beş saniyelik zaman aşımı vardır. Belirteçte iptal istendiğinde:

  • Uygulamanın gerçekleştirdiği tüm arka plan işlemleri durdurulmalıdır.
  • içinde StopAsync çağrılan tüm yöntemler hemen döndürülmelidir.

Ancak iptal istendikten sonra görevler iptal edilmez; çağıran tüm görevlerin tamamlanmasını bekler.

Uygulama beklenmedik bir şekilde kapanırsa (örneğin, uygulamanın işlemi başarısız olursa) StopAsync çağrılmayabilir. Bu nedenle, veya içinde StopAsync gerçekleştirilen işlemler adlı herhangi bir yöntem gerçekleşmeyebilir.

Varsayılan beş saniyelik kapatma zaman aşımını uzatmak için şunu ayarlayın:

Barındırılan hizmet, uygulama başlangıcında bir kez etkinleştirilir ve uygulama kapatıldığında düzgün bir şekilde kapatılır. Arka plan görevi yürütme sırasında hata oluşursa, Dispose çağrılmasa StopAsync bile çağrılmalıdır.

BackgroundService temel sınıfı

BackgroundService , uzun süre çalışan IHostedServicebir uygulamak için temel bir sınıftır.

Arka plan hizmetini çalıştırmak için ExecuteAsync(CancellationToken) çağrılır. Uygulama, arka plan hizmetinin tüm ömrünü temsil eden bir Task döndürür. ExecuteAsync çağrılarak awaitzaman uyumsuz hale gelene kadar başka hizmet başlatılmaz. 'de ExecuteAsyncuzun ve engelleyici başlatma çalışması yapmaktan kaçının. StopAsync(CancellationToken) içindeki konak blokları tamamlanmasını bekliyorExecuteAsync.

IHostedService.StopAsync çağrıldığında iptal belirteci tetikleniyor. hizmeti düzgün bir şekilde kapatmak için iptal belirteci tetiklendiğinde uygulamanızın ExecuteAsync hemen bitmesi gerekir. Aksi takdirde, hizmet kapatma zaman aşımında düzgün bir şekilde kapatılır. Daha fazla bilgi için IHostedService arabirimi bölümüne bakın.

Daha fazla bilgi için bkz. BackgroundService kaynak kodu.

Zamanlanmış arka plan görevleri

Zamanlanmış bir arka plan görevi System.Threading.Timer sınıfını kullanır. Zamanlayıcı, görevin DoWork yöntemini tetikler. Hizmet kapsayıcısı üzerinde StopAsync atıldığında zamanlayıcı devre dışı bırakılır ve atılır Dispose:

public class TimedHostedService : IHostedService, IDisposable
{
    private int executionCount = 0;
    private readonly ILogger<TimedHostedService> _logger;
    private Timer? _timer = null;

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

    public Task StartAsync(CancellationToken stoppingToken)
    {
        _logger.LogInformation("Timed Hosted Service running.");

        _timer = new Timer(DoWork, null, TimeSpan.Zero,
            TimeSpan.FromSeconds(5));

        return Task.CompletedTask;
    }

    private void DoWork(object? state)
    {
        var count = Interlocked.Increment(ref executionCount);

        _logger.LogInformation(
            "Timed Hosted Service is working. Count: {Count}", count);
    }

    public Task StopAsync(CancellationToken stoppingToken)
    {
        _logger.LogInformation("Timed Hosted Service is stopping.");

        _timer?.Change(Timeout.Infinite, 0);

        return Task.CompletedTask;
    }

    public void Dispose()
    {
        _timer?.Dispose();
    }
}

Timer önceki yürütmelerinin DoWork bitmesini beklemez, bu nedenle gösterilen yaklaşım her senaryo için uygun olmayabilir. Interlocked.Increment , birden çok iş parçacığının eşzamanlı olarak güncelleştirilmesini executionCount engelleyen bir atomik işlem olarak yürütme sayacını artırmak için kullanılır.

Hizmet uzantı yöntemiyle AddHostedService (Program.cs) kaydedilir IHostBuilder.ConfigureServices :

services.AddHostedService<TimedHostedService>();

Bir arka plan görevinde kapsamı belirlenmiş bir hizmeti kullanma

BackgroundService içinde kapsamı belirlenmiş hizmetleri kullanmak için bir kapsam oluşturun. Barındırılan bir hizmet için varsayılan olarak hiçbir kapsam oluşturulmaz.

Kapsamı belirlenmiş arka plan görev hizmeti, arka plan görevinin mantığını içerir. Aşağıdaki örnekte:

  • Hizmet zaman uyumsuzdur. DoWork yöntemi bir Taskdöndürür. Gösterim amacıyla, yönteminde on saniyelik bir gecikme beklenmektedir DoWork .
  • ILogger hizmete eklenir.
internal interface IScopedProcessingService
{
    Task DoWork(CancellationToken stoppingToken);
}

internal class ScopedProcessingService : IScopedProcessingService
{
    private int executionCount = 0;
    private readonly ILogger _logger;
    
    public ScopedProcessingService(ILogger<ScopedProcessingService> logger)
    {
        _logger = logger;
    }

    public async Task DoWork(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            executionCount++;

            _logger.LogInformation(
                "Scoped Processing Service is working. Count: {Count}", executionCount);

            await Task.Delay(10000, stoppingToken);
        }
    }
}

Barındırılan hizmet, yöntemini çağırmak DoWork üzere kapsamı belirlenmiş arka plan görev hizmetini çözümlemek için bir kapsam oluşturur. DoWorkiçinde beklenen ExecuteAsyncbir Taskdöndürür:

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

    public ConsumeScopedServiceHostedService(IServiceProvider services, 
        ILogger<ConsumeScopedServiceHostedService> logger)
    {
        Services = services;
        _logger = logger;
    }

    public IServiceProvider Services { get; }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        _logger.LogInformation(
            "Consume Scoped Service Hosted Service running.");

        await DoWork(stoppingToken);
    }

    private async Task DoWork(CancellationToken stoppingToken)
    {
        _logger.LogInformation(
            "Consume Scoped Service Hosted Service is working.");

        using (var scope = Services.CreateScope())
        {
            var scopedProcessingService = 
                scope.ServiceProvider
                    .GetRequiredService<IScopedProcessingService>();

            await scopedProcessingService.DoWork(stoppingToken);
        }
    }

    public override async Task StopAsync(CancellationToken stoppingToken)
    {
        _logger.LogInformation(
            "Consume Scoped Service Hosted Service is stopping.");

        await base.StopAsync(stoppingToken);
    }
}

Hizmetler (Program.cs içinde IHostBuilder.ConfigureServices kayıtlıdır). Barındırılan hizmet uzantı yöntemiyle AddHostedService kaydedilir:

services.AddHostedService<ConsumeScopedServiceHostedService>();
services.AddScoped<IScopedProcessingService, ScopedProcessingService>();

Kuyruğa alınan arka plan görevleri

Arka plan görev kuyruğu .NET 4.x'i QueueBackgroundWorkItemtemel alır:

public interface IBackgroundTaskQueue
{
    ValueTask QueueBackgroundWorkItemAsync(Func<CancellationToken, ValueTask> workItem);

    ValueTask<Func<CancellationToken, ValueTask>> DequeueAsync(
        CancellationToken cancellationToken);
}

public class BackgroundTaskQueue : IBackgroundTaskQueue
{
    private readonly Channel<Func<CancellationToken, ValueTask>> _queue;

    public BackgroundTaskQueue(int capacity)
    {
        // Capacity should be set based on the expected application load and
        // number of concurrent threads accessing the queue.            
        // BoundedChannelFullMode.Wait will cause calls to WriteAsync() to return a task,
        // which completes only when space became available. This leads to backpressure,
        // in case too many publishers/calls start accumulating.
        var options = new BoundedChannelOptions(capacity)
        {
            FullMode = BoundedChannelFullMode.Wait
        };
        _queue = Channel.CreateBounded<Func<CancellationToken, ValueTask>>(options);
    }

    public async ValueTask QueueBackgroundWorkItemAsync(
        Func<CancellationToken, ValueTask> workItem)
    {
        if (workItem == null)
        {
            throw new ArgumentNullException(nameof(workItem));
        }

        await _queue.Writer.WriteAsync(workItem);
    }

    public async ValueTask<Func<CancellationToken, ValueTask>> DequeueAsync(
        CancellationToken cancellationToken)
    {
        var workItem = await _queue.Reader.ReadAsync(cancellationToken);

        return workItem;
    }
}

Aşağıdaki QueueHostedService örnekte:

  • BackgroundProcessing yöntemi içinde beklenen ExecuteAsyncbir Taskdöndürür.
  • Kuyruktaki arka plan görevleri içinde sıralanır ve yürütülür BackgroundProcessing.
  • hizmet uygulamasında StopAsyncdurdurulmadan önce iş öğeleri beklenir.
public class QueuedHostedService : BackgroundService
{
    private readonly ILogger<QueuedHostedService> _logger;

    public QueuedHostedService(IBackgroundTaskQueue taskQueue, 
        ILogger<QueuedHostedService> logger)
    {
        TaskQueue = taskQueue;
        _logger = logger;
    }

    public IBackgroundTaskQueue TaskQueue { get; }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        _logger.LogInformation(
            $"Queued Hosted Service is running.{Environment.NewLine}" +
            $"{Environment.NewLine}Tap W to add a work item to the " +
            $"background queue.{Environment.NewLine}");

        await BackgroundProcessing(stoppingToken);
    }

    private async Task BackgroundProcessing(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            var workItem = 
                await TaskQueue.DequeueAsync(stoppingToken);

            try
            {
                await workItem(stoppingToken);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, 
                    "Error occurred executing {WorkItem}.", nameof(workItem));
            }
        }
    }

    public override async Task StopAsync(CancellationToken stoppingToken)
    {
        _logger.LogInformation("Queued Hosted Service is stopping.");

        await base.StopAsync(stoppingToken);
    }
}

Bir MonitorLoop hizmet, giriş cihazında anahtar her seçildiğinde barındırılan w hizmet için sıralama görevlerini işler:

  • IBackgroundTaskQueue hizmete eklenirMonitorLoop.
  • IBackgroundTaskQueue.QueueBackgroundWorkItem bir iş öğesini sıralamak için çağrılır.
  • İş öğesi, uzun süre çalışan bir arka plan görevinin benzetimini gerçekleştirir:
    • Üç 5 saniyelik gecikme yürütülür (Task.Delay).
    • try-catch Görev iptal edilirse bir deyim yakalanıyorOperationCanceledException.
public class MonitorLoop
{
    private readonly IBackgroundTaskQueue _taskQueue;
    private readonly ILogger _logger;
    private readonly CancellationToken _cancellationToken;

    public MonitorLoop(IBackgroundTaskQueue taskQueue,
        ILogger<MonitorLoop> logger,
        IHostApplicationLifetime applicationLifetime)
    {
        _taskQueue = taskQueue;
        _logger = logger;
        _cancellationToken = applicationLifetime.ApplicationStopping;
    }

    public void StartMonitorLoop()
    {
        _logger.LogInformation("MonitorAsync Loop is starting.");

        // Run a console user input loop in a background thread
        Task.Run(async () => await MonitorAsync());
    }

    private async ValueTask MonitorAsync()
    {
        while (!_cancellationToken.IsCancellationRequested)
        {
            var keyStroke = Console.ReadKey();

            if (keyStroke.Key == ConsoleKey.W)
            {
                // Enqueue a background work item
                await _taskQueue.QueueBackgroundWorkItemAsync(BuildWorkItem);
            }
        }
    }

    private async ValueTask BuildWorkItem(CancellationToken token)
    {
        // Simulate three 5-second tasks to complete
        // for each enqueued work item

        int delayLoop = 0;
        var guid = Guid.NewGuid().ToString();

        _logger.LogInformation("Queued Background Task {Guid} is starting.", guid);

        while (!token.IsCancellationRequested && delayLoop < 3)
        {
            try
            {
                await Task.Delay(TimeSpan.FromSeconds(5), token);
            }
            catch (OperationCanceledException)
            {
                // Prevent throwing if the Delay is cancelled
            }

            delayLoop++;

            _logger.LogInformation("Queued Background Task {Guid} is running. " 
                                   + "{DelayLoop}/3", guid, delayLoop);
        }

        if (delayLoop == 3)
        {
            _logger.LogInformation("Queued Background Task {Guid} is complete.", guid);
        }
        else
        {
            _logger.LogInformation("Queued Background Task {Guid} was cancelled.", guid);
        }
    }
}

Hizmetler (Program.cs içinde IHostBuilder.ConfigureServices kayıtlıdır). Barındırılan hizmet uzantı yöntemiyle AddHostedService kaydedilir:

services.AddSingleton<MonitorLoop>();
services.AddHostedService<QueuedHostedService>();
services.AddSingleton<IBackgroundTaskQueue>(ctx =>
{
    if (!int.TryParse(hostContext.Configuration["QueueCapacity"], out var queueCapacity))
        queueCapacity = 100;
    return new BackgroundTaskQueue(queueCapacity);
});

MonitorLoop içinde Program.csbaşlatılır:

var monitorLoop = host.Services.GetRequiredService<MonitorLoop>();
monitorLoop.StartMonitorLoop();

Ek kaynaklar

ASP.NET Core'da arka plan görevleri barındırılan hizmetler olarak uygulanabilir. Barındırılan hizmet, arabirimini uygulayan arka plan görev mantığına sahip bir sınıftır IHostedService . Bu makalede üç barındırılan hizmet örneği verilmiştir:

  • Zamanlayıcı üzerinde çalışan arka plan görevi.
  • Kapsamlı bir hizmeti etkinleştiren barındırılan hizmet. Kapsamı belirlenmiş hizmet bağımlılık eklemeyi (DI) kullanabilir.
  • Sıralı olarak çalışan kuyruğa alınmış arka plan görevleri.

Örnek kodu görüntüleme veya indirme (indirme)

Çalışan Hizmeti şablonu

ASP.NET Core Çalışan Hizmeti şablonu, uzun süre çalışan hizmet uygulamaları yazmak için bir başlangıç noktası sağlar. Çalışan Hizmeti şablonundan oluşturulan bir uygulama, proje dosyasında Çalışan SDK'sını belirtir:

<Project Sdk="Microsoft.NET.Sdk.Worker">

Şablonu barındırılan hizmetler uygulamasında temel olarak kullanmak için:

  1. Yeni bir proje oluşturma.
  2. Çalışan Hizmeti'ne tıklayın. İleri’yi seçin.
  3. Proje adı alanına bir proje adı girin veya varsayılan proje adını kabul edin. Oluştur’u seçin.
  4. Yeni Çalışan hizmeti oluştur iletişim kutusunda Oluştur'u seçin.

Paket

Çalışan Hizmeti şablonunu temel alan bir uygulama SDK'yi Microsoft.NET.Sdk.Worker kullanır ve Microsoft.Extensions.Hosting paketine yönelik açık bir paket başvurusuna sahiptir. Örneğin, örnek uygulamanın proje dosyasına ( )BackgroundTasksSample.csproj bakın.

SDK kullanan Microsoft.NET.Sdk.Web web uygulamaları için Microsoft.Extensions.Hosting paketine paylaşılan çerçeveden örtük olarak başvurulur. Uygulamanın proje dosyasında açık bir paket başvurusu gerekli değildir.

IHostedService arabirimi

Arabirimi, IHostedService konak tarafından yönetilen nesneler için iki yöntem tanımlar:

StartAsync

StartAsync arka plan görevini başlatma mantığını içerir. StartAsync daha önce çağrılır:

Uygulamanın işlem hattı yapılandırıldıktan ve ApplicationStarted çağrıldıktan sonra barındırılan hizmetin StartAsync çalışması için varsayılan davranış değiştirilebilir. Varsayılan davranışı değiştirmek için çağrısı yaptıktan sonra ConfigureWebHostDefaultsbarındırılan hizmeti (VideosWatcheraşağıdaki örnekte) ekleyin:

using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
public class Program
{
    public static void Main(string[] args)
    {
        CreateHostBuilder(args).Build().Run();
    }
    public static IHostBuilder CreateHostBuilder(string[] args) =>
        Host.CreateDefaultBuilder(args)
            .ConfigureWebHostDefaults(webBuilder =>
            {
                webBuilder.UseStartup<Startup>();
            })
            .ConfigureServices(services =>
            {
                services.AddHostedService<VideosWatcher>();
            });
}

StopAsync

İptal belirtecinin kapatma işleminin artık düzgün olmaması gerektiğini belirtmek için varsayılan beş saniyelik zaman aşımı vardır. Belirteçte iptal istendiğinde:

  • Uygulamanın gerçekleştirdiği tüm arka plan işlemleri durdurulmalıdır.
  • içinde StopAsync çağrılan tüm yöntemler hemen döndürülmelidir.

Ancak iptal istendikten sonra görevler iptal edilmez; çağıran tüm görevlerin tamamlanmasını bekler.

Uygulama beklenmedik bir şekilde kapanırsa (örneğin, uygulamanın işlemi başarısız olursa) StopAsync çağrılmayabilir. Bu nedenle, veya içinde StopAsync gerçekleştirilen işlemler adlı herhangi bir yöntem gerçekleşmeyebilir.

Varsayılan beş saniyelik kapatma zaman aşımını uzatmak için şunu ayarlayın:

Barındırılan hizmet, uygulama başlangıcında bir kez etkinleştirilir ve uygulama kapatıldığında düzgün bir şekilde kapatılır. Arka plan görevi yürütme sırasında hata oluşursa, Dispose çağrılmasa StopAsync bile çağrılmalıdır.

BackgroundService temel sınıfı

BackgroundService , uzun süre çalışan IHostedServicebir uygulamak için temel bir sınıftır.

Arka plan hizmetini çalıştırmak için ExecuteAsync(CancellationToken) çağrılır. Uygulama, arka plan hizmetinin tüm ömrünü temsil eden bir Task döndürür. ExecuteAsync çağrılarak awaitzaman uyumsuz hale gelene kadar başka hizmet başlatılmaz. 'de ExecuteAsyncuzun ve engelleyici başlatma çalışması yapmaktan kaçının. StopAsync(CancellationToken) içindeki konak blokları tamamlanmasını bekliyorExecuteAsync.

IHostedService.StopAsync çağrıldığında iptal belirteci tetikleniyor. hizmeti düzgün bir şekilde kapatmak için iptal belirteci tetiklendiğinde uygulamanızın ExecuteAsync hemen bitmesi gerekir. Aksi takdirde, hizmet kapatma zaman aşımında düzgün bir şekilde kapatılır. Daha fazla bilgi için IHostedService arabirimi bölümüne bakın.

StartAsync barındırılan hizmetler sıralı olarak çalıştırıldığından ve çalıştırmalar tamamlanıncaya kadar StartAsync başka hizmet başlatılmadığından, kısa süre çalışan görevlerle sınırlı olmalıdır. Uzun süre çalışan görevler içine ExecuteAsyncyerleştirilmelidir. Daha fazla bilgi için backgroundservice kaynağına bakın.

Zamanlanmış arka plan görevleri

Zamanlanmış bir arka plan görevi System.Threading.Timer sınıfını kullanır. Zamanlayıcı, görevin DoWork yöntemini tetikler. Hizmet kapsayıcısı üzerinde StopAsync atıldığında zamanlayıcı devre dışı bırakılır ve atılır Dispose:

public class TimedHostedService : IHostedService, IDisposable
{
    private int executionCount = 0;
    private readonly ILogger<TimedHostedService> _logger;
    private Timer _timer;

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

    public Task StartAsync(CancellationToken stoppingToken)
    {
        _logger.LogInformation("Timed Hosted Service running.");

        _timer = new Timer(DoWork, null, TimeSpan.Zero, 
            TimeSpan.FromSeconds(5));

        return Task.CompletedTask;
    }

    private void DoWork(object state)
    {
        var count = Interlocked.Increment(ref executionCount);

        _logger.LogInformation(
            "Timed Hosted Service is working. Count: {Count}", count);
    }

    public Task StopAsync(CancellationToken stoppingToken)
    {
        _logger.LogInformation("Timed Hosted Service is stopping.");

        _timer?.Change(Timeout.Infinite, 0);

        return Task.CompletedTask;
    }

    public void Dispose()
    {
        _timer?.Dispose();
    }
}

Timer önceki yürütmelerinin DoWork bitmesini beklemez, bu nedenle gösterilen yaklaşım her senaryo için uygun olmayabilir. Interlocked.Increment , birden çok iş parçacığının eşzamanlı olarak güncelleştirilmesini executionCount engelleyen bir atomik işlem olarak yürütme sayacını artırmak için kullanılır.

Hizmet uzantı yöntemiyle AddHostedService (Program.cs) kaydedilir IHostBuilder.ConfigureServices :

services.AddHostedService<TimedHostedService>();

Bir arka plan görevinde kapsamı belirlenmiş bir hizmeti kullanma

BackgroundService içinde kapsamı belirlenmiş hizmetleri kullanmak için bir kapsam oluşturun. Barındırılan bir hizmet için varsayılan olarak hiçbir kapsam oluşturulmaz.

Kapsamı belirlenmiş arka plan görev hizmeti, arka plan görevinin mantığını içerir. Aşağıdaki örnekte:

  • Hizmet zaman uyumsuzdur. DoWork yöntemi bir Taskdöndürür. Gösterim amacıyla, yönteminde on saniyelik bir gecikme beklenmektedir DoWork .
  • ILogger hizmete eklenir.
internal interface IScopedProcessingService
{
    Task DoWork(CancellationToken stoppingToken);
}

internal class ScopedProcessingService : IScopedProcessingService
{
    private int executionCount = 0;
    private readonly ILogger _logger;
    
    public ScopedProcessingService(ILogger<ScopedProcessingService> logger)
    {
        _logger = logger;
    }

    public async Task DoWork(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            executionCount++;

            _logger.LogInformation(
                "Scoped Processing Service is working. Count: {Count}", executionCount);

            await Task.Delay(10000, stoppingToken);
        }
    }
}

Barındırılan hizmet, yöntemini çağırmak DoWork üzere kapsamı belirlenmiş arka plan görev hizmetini çözümlemek için bir kapsam oluşturur. DoWorkiçinde beklenen ExecuteAsyncbir Taskdöndürür:

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

    public ConsumeScopedServiceHostedService(IServiceProvider services, 
        ILogger<ConsumeScopedServiceHostedService> logger)
    {
        Services = services;
        _logger = logger;
    }

    public IServiceProvider Services { get; }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        _logger.LogInformation(
            "Consume Scoped Service Hosted Service running.");

        await DoWork(stoppingToken);
    }

    private async Task DoWork(CancellationToken stoppingToken)
    {
        _logger.LogInformation(
            "Consume Scoped Service Hosted Service is working.");

        using (var scope = Services.CreateScope())
        {
            var scopedProcessingService = 
                scope.ServiceProvider
                    .GetRequiredService<IScopedProcessingService>();

            await scopedProcessingService.DoWork(stoppingToken);
        }
    }

    public override async Task StopAsync(CancellationToken stoppingToken)
    {
        _logger.LogInformation(
            "Consume Scoped Service Hosted Service is stopping.");

        await base.StopAsync(stoppingToken);
    }
}

Hizmetler (Program.cs içinde IHostBuilder.ConfigureServices kayıtlıdır). Barındırılan hizmet uzantı yöntemiyle AddHostedService kaydedilir:

services.AddHostedService<ConsumeScopedServiceHostedService>();
services.AddScoped<IScopedProcessingService, ScopedProcessingService>();

Kuyruğa alınan arka plan görevleri

Arka plan görev kuyruğu .NET 4.x'i QueueBackgroundWorkItemtemel alır:

public interface IBackgroundTaskQueue
{
    ValueTask QueueBackgroundWorkItemAsync(Func<CancellationToken, ValueTask> workItem);

    ValueTask<Func<CancellationToken, ValueTask>> DequeueAsync(
        CancellationToken cancellationToken);
}

public class BackgroundTaskQueue : IBackgroundTaskQueue
{
    private readonly Channel<Func<CancellationToken, ValueTask>> _queue;

    public BackgroundTaskQueue(int capacity)
    {
        // Capacity should be set based on the expected application load and
        // number of concurrent threads accessing the queue.            
        // BoundedChannelFullMode.Wait will cause calls to WriteAsync() to return a task,
        // which completes only when space became available. This leads to backpressure,
        // in case too many publishers/calls start accumulating.
        var options = new BoundedChannelOptions(capacity)
        {
            FullMode = BoundedChannelFullMode.Wait
        };
        _queue = Channel.CreateBounded<Func<CancellationToken, ValueTask>>(options);
    }

    public async ValueTask QueueBackgroundWorkItemAsync(
        Func<CancellationToken, ValueTask> workItem)
    {
        if (workItem == null)
        {
            throw new ArgumentNullException(nameof(workItem));
        }

        await _queue.Writer.WriteAsync(workItem);
    }

    public async ValueTask<Func<CancellationToken, ValueTask>> DequeueAsync(
        CancellationToken cancellationToken)
    {
        var workItem = await _queue.Reader.ReadAsync(cancellationToken);

        return workItem;
    }
}

Aşağıdaki QueueHostedService örnekte:

  • BackgroundProcessing yöntemi içinde beklenen ExecuteAsyncbir Taskdöndürür.
  • Kuyruktaki arka plan görevleri içinde sıralanır ve yürütülür BackgroundProcessing.
  • hizmet uygulamasında StopAsyncdurdurulmadan önce iş öğeleri beklenir.
public class QueuedHostedService : BackgroundService
{
    private readonly ILogger<QueuedHostedService> _logger;

    public QueuedHostedService(IBackgroundTaskQueue taskQueue, 
        ILogger<QueuedHostedService> logger)
    {
        TaskQueue = taskQueue;
        _logger = logger;
    }

    public IBackgroundTaskQueue TaskQueue { get; }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        _logger.LogInformation(
            $"Queued Hosted Service is running.{Environment.NewLine}" +
            $"{Environment.NewLine}Tap W to add a work item to the " +
            $"background queue.{Environment.NewLine}");

        await BackgroundProcessing(stoppingToken);
    }

    private async Task BackgroundProcessing(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            var workItem = 
                await TaskQueue.DequeueAsync(stoppingToken);

            try
            {
                await workItem(stoppingToken);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, 
                    "Error occurred executing {WorkItem}.", nameof(workItem));
            }
        }
    }

    public override async Task StopAsync(CancellationToken stoppingToken)
    {
        _logger.LogInformation("Queued Hosted Service is stopping.");

        await base.StopAsync(stoppingToken);
    }
}

Bir MonitorLoop hizmet, giriş cihazında anahtar her seçildiğinde barındırılan w hizmet için sıralama görevlerini işler:

  • IBackgroundTaskQueue hizmete eklenirMonitorLoop.
  • IBackgroundTaskQueue.QueueBackgroundWorkItem bir iş öğesini sıralamak için çağrılır.
  • İş öğesi, uzun süre çalışan bir arka plan görevinin benzetimini gerçekleştirir:
    • Üç 5 saniyelik gecikme yürütülür (Task.Delay).
    • try-catch Görev iptal edilirse bir deyim yakalanıyorOperationCanceledException.
public class MonitorLoop
{
    private readonly IBackgroundTaskQueue _taskQueue;
    private readonly ILogger _logger;
    private readonly CancellationToken _cancellationToken;

    public MonitorLoop(IBackgroundTaskQueue taskQueue, 
        ILogger<MonitorLoop> logger, 
        IHostApplicationLifetime applicationLifetime)
    {
        _taskQueue = taskQueue;
        _logger = logger;
        _cancellationToken = applicationLifetime.ApplicationStopping;
    }

    public void StartMonitorLoop()
    {
        _logger.LogInformation("MonitorAsync Loop is starting.");

        // Run a console user input loop in a background thread
        Task.Run(async () => await MonitorAsync());
    }

    private async ValueTask MonitorAsync()
    {
        while (!_cancellationToken.IsCancellationRequested)
        {
            var keyStroke = Console.ReadKey();

            if (keyStroke.Key == ConsoleKey.W)
            {
                // Enqueue a background work item
                await _taskQueue.QueueBackgroundWorkItemAsync(BuildWorkItem);
            }
        }
    }

    private async ValueTask BuildWorkItem(CancellationToken token)
    {
        // Simulate three 5-second tasks to complete
        // for each enqueued work item

        int delayLoop = 0;
        var guid = Guid.NewGuid().ToString();

        _logger.LogInformation("Queued Background Task {Guid} is starting.", guid);

        while (!token.IsCancellationRequested && delayLoop < 3)
        {
            try
            {
                await Task.Delay(TimeSpan.FromSeconds(5), token);
            }
            catch (OperationCanceledException)
            {
                // Prevent throwing if the Delay is cancelled
            }

            delayLoop++;

            _logger.LogInformation("Queued Background Task {Guid} is running. " + "{DelayLoop}/3", guid, delayLoop);
        }

        if (delayLoop == 3)
        {
            _logger.LogInformation("Queued Background Task {Guid} is complete.", guid);
        }
        else
        {
            _logger.LogInformation("Queued Background Task {Guid} was cancelled.", guid);
        }
    }
}

Hizmetler (Program.cs içinde IHostBuilder.ConfigureServices kayıtlıdır). Barındırılan hizmet uzantı yöntemiyle AddHostedService kaydedilir:

services.AddSingleton<MonitorLoop>();
services.AddHostedService<QueuedHostedService>();
services.AddSingleton<IBackgroundTaskQueue>(ctx => {
    if (!int.TryParse(hostContext.Configuration["QueueCapacity"], out var queueCapacity))
        queueCapacity = 100;
    return new BackgroundTaskQueue(queueCapacity);
});

MonitorLoop içinde Program.Mainbaşlatılır:

var monitorLoop = host.Services.GetRequiredService<MonitorLoop>();
monitorLoop.StartMonitorLoop();

Ek kaynaklar