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, arabirimi 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 ekleme (DI) kullanabilir.
• Sıralı olarak çalışan kuyruğa alınmış arka plan görevleri.

Çalışan Hizmeti şablonu

ASP.NET Temel Ç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ının temeli olarak kullanmak için:

Visual Studio

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 bilgi iletişim kutusunda Çerçeve Seçin. Oluştur'u belirleyin.

Mac için Visual Studio

1. Yeni bir proje oluşturma.
2. Kenar çubuğunda .NET Core altında Uygulama'ya tıklayın.
3. ASP.NET Core altında Çalışan'ı seçin. İleri'yi seçin.
4. Hedef Çerçeve için .NET Core 3.1 veya üzerini seçin. İleri'yi seçin.
5. Proje Adı alanına bir ad girin. Oluştur'u belirleyin.

.NET Core CLI

Çalışan Hizmeti (worker) şablonunu bir komut kabuğundan dotnet new komutuyla kullanın. Aşağıdaki örnekte adlı ContosoWorkerbir Çalışan Hizmeti uygulaması oluşturulur. Komut yürütülürken uygulama için ContosoWorker otomatik olarak bir klasör oluşturulur.

dotnet new worker -o ContosoWorker

Paket

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

SDK kullanan web uygulamaları için Microsoft.NET.Sdk.Web 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

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

• StartAsync(CancellationToken)
• StopAsync(CancellationToken)

StartAsync

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

• Uygulamanın istek işleme işlem hattı yapılandırılır.
• Sunucu başlatılır ve IApplicationLifetime.ApplicationStarted tetiklendi .

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

StopAsync

• Konak düzgün bir kapatma gerçekleştirdiğinde StopAsync(CancellationToken) tetiklenir. StopAsync arka plan görevini sonlandırma mantığını içerir. IDisposableYönetilmeyen kaynakları atmak için uygulayıp sonlandırıcılar (yıkıcılar).

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

• Uygulamanın gerçekleştirdiği kalan 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 terk 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 gerçekleştirilen StopAsync işlemler adlı herhangi bir yöntem gerçekleşmeyebilir.

Varsayılan 30 saniyelik kapatma zaman aşımını genişletmek için şunu ayarlayın:

• ShutdownTimeout Genel Ana Bilgisayar kullanılırken. Daha fazla bilgi için, bkz. ASP.NET Core'da .NET Genel Ana Bilgisayarı.
• Web Konağı kullanılırken kapatma zaman aşımı ana bilgisayar yapılandırma ayarı. Daha fazla bilgi için bkz . ASP.NET Core Web Host.

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 zaman uyumsuz hale gelene kadar, örneğin çağrısı awaityaparak başka hizmet başlatılmaz. içinde ExecuteAsyncuzun, başlatmayı engelleyen bir çalışma gerçekleştirmekten kaçının. StopAsync(CancellationToken) içindeki konak blokları tamamlanmasını bekliyorExecuteAsync.

IHostedService.StopAsync çağrıldığında iptal belirteci tetikleniyor. uygulamasının ExecuteAsync , hizmeti düzgün bir şekilde kapatmak için iptal belirteci tetiklendiğinde 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ış arka plan görevi System.Threading.Timer sınıfını kullanır. Zamanlayıcı, görevin DoWork yöntemini tetikler. Zamanlayıcı üzerinde devre dışı bırakılır StopAsync ve hizmet kapsayıcısı üzerinde Disposeatıldığında atılır:

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 tamamlanmasını 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) içinde kaydedilir IHostBuilder.ConfigureServices :

services.AddHostedService<TimedHostedService>();

Bir arka plan görevinde kapsamlı hizmet kullanma

Kapsamı belirlenmiş hizmetleri bir BackgroundService içinde 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 uyumsuz. DoWork yöntemi bir Taskdöndürür. Gösterim amacıyla, yönteminde on saniyelik bir gecikme beklenmektedir DoWork .
• ILogger hizmetine 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 kapsamlı 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 durdurulmadan StopAsyncö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 seçildiğinde barındırılan w hizmet için sıralama görevlerini işler:

• IBackgroundTaskQueue hizmetine 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();

Zaman uyumsuz zamanlanmış arka plan görevi

Aşağıdaki kod zaman uyumsuz zamanlanmış bir arka plan görevi oluşturur:

namespace TimedBackgroundTasks;

public class TimedHostedService : BackgroundService
{
    private readonly ILogger<TimedHostedService> _logger;
    private int _executionCount;

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

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

        // When the timer should have no due-time, then do the work once now.
        DoWork();

        using PeriodicTimer timer = new(TimeSpan.FromSeconds(1));

        try
        {
            while (await timer.WaitForNextTickAsync(stoppingToken))
            {
                DoWork();
            }
        }
        catch (OperationCanceledException)
        {
            _logger.LogInformation("Timed Hosted Service is stopping.");
        }
    }

    // Could also be a async method, that can be awaited in ExecuteAsync above
    private void DoWork()
    {
        int count = Interlocked.Increment(ref _executionCount);

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

Yerel AOT

Çalışan Hizmeti şablonları, bayrağıyla --aot .NET yerelini önceden (AOT) destekler:

Visual Studio

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 bilgi iletişim kutusunda:
5. Bir Çerçeve seçin.
6. Yerel AOT yayımlamayı etkinleştir onay kutusunu işaretleyin.
7. Oluştur'u belirleyin.

.NET Core CLI

AOT seçeneğiyle bir komut kabuğundan dotnet new komutuyla Çalışan Hizmeti (worker) şablonunu kullanın:

dotnet new worker -o WorkerWithAot --aot

AOT seçeneği proje dosyasına ekler <PublishAot>true</PublishAot> :

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

  <PropertyGroup>
    <TargetFramework>net8.0</TargetFramework>
    <Nullable>enable</Nullable>
    <ImplicitUsings>enable</ImplicitUsings>
    <InvariantGlobalization>true</InvariantGlobalization>
+   <PublishAot>true</PublishAot>
    <UserSecretsId>dotnet-WorkerWithAot-e94b2</UserSecretsId>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Microsoft.Extensions.Hosting" Version="8.0.0-preview.4.23259.5" />
  </ItemGroup>
</Project>

Ek kaynaklar

• GitHub'da arka plan hizmetleri birim testleri.
• Örnek kodu görüntüleme veya indirme (indirme)
• IHostedService ve BackgroundService sınıfıyla mikro hizmetlerde arka plan görevleri uygulama
• Azure Uygulaması Hizmetinde Web İşleri ile arka plan görevlerini çalıştırma
• Timer