C# ワーカースレッドの実装と最適化：BackgroundServiceを活用した効率的なバックグラウンド処理

// Microsoft.Extensions.Hostingの参照が必要です
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;

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

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

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        _logger.LogInformation("SampleWorker が開始されました。");

        // stoppingTokenはアプリケーションの停止を検知します
        while (!stoppingToken.IsCancellationRequested)
        {
            _logger.LogInformation("ワーカースレッドが稼働中です: {time}", DateTimeOffset.Now);

            try
            {
                // 5秒間待機します
                await Task.Delay(5000, stoppingToken);
            }
            catch (OperationCanceledException)
            {
                // タスクキャンセル時は正常終了として扱います
                break;
            }
        }

        _logger.LogInformation("SampleWorker が停止しました。");
    }
}

SampleWorker が開始されました。
ワーカースレッドが稼働中です: 2026/05/20 10:00:00 +09:00
ワーカースレッドが稼働中です: 2026/05/20 10:00:05 +09:00

public class DatabaseWorker : BackgroundService
{
    private readonly ILogger<DatabaseWorker> _logger;
    private readonly IServiceScopeFactory _scopeFactory;

    public DatabaseWorker(ILogger<DatabaseWorker> logger, IServiceScopeFactory scopeFactory)
    {
        _logger = logger;
        _scopeFactory = scopeFactory;
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            using (var scope = _scopeFactory.CreateScope())
            {
                // スコープ内からのみ取得可能なサービスを取得
                var myService = scope.ServiceProvider.GetRequiredService<IMyScopedService>();
                await myService.DoWorkAsync(stoppingToken);
            }

            await Task.Delay(TimeSpan.FromMinutes(1), stoppingToken);
        }
    }
}

using System.Threading.Channels;

public class HighPerformanceWorker : BackgroundService
{
    private readonly ChannelReader<string> _reader;
    private readonly ILogger<HighPerformanceWorker> _logger;

    public HighPerformanceWorker(ChannelReader<string> reader, ILogger<HighPerformanceWorker> logger)
    {
        _reader = reader;
        _logger = logger;
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        // WaitToReadAsyncにより、データが来るまでスレッドを効率的に待機させます
        await foreach (var item in _reader.ReadAllAsync(stoppingToken))
        {
            try
            {
                _logger.LogInformation("処理中のアイテム: {item}", item);
                // ここに重いビジネスロジックを記述
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "アイテムの処理中にエラーが発生しました。");
            }
        }
    }
}

protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
    int retryCount = 0;

    while (!stoppingToken.IsCancellationRequested)
    {
        try
        {
            await ProcessTaskAsync(stoppingToken);
            retryCount = 0; // 成功したらカウントをリセット
        }
        catch (Exception ex)
        {
            retryCount++;
            int delaySeconds = Math.Min((int)Math.Pow(2, retryCount), 60);
            
            _logger.LogError(ex, "{delay}秒後に再試行します。", delaySeconds);
            await Task.Delay(TimeSpan.FromSeconds(delaySeconds), stoppingToken);
        }
    }
}

protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
    var items = Enumerable.Range(1, 100).Select(i => $"Task-{i}");

    var options = new ParallelOptions
    {
        MaxDegreeOfParallelism = 4, // 最大並列度を指定
        CancellationToken = stoppingToken
    };

    await Parallel.ForEachAsync(items, options, async (item, token) =>
    {
        await DoWorkInternalAsync(item, token);
    });
}