聆途笔记

C#后台服务编写

引言

后台服务是现代应用程序架构中不可或缺的组成部分，它们负责处理各种不需要用户直接交互的任务，如数据处理、定时作业、消息队列消费等。在C#生态系统中，开发者有多种实现后台服务的选择，从传统的Windows服务到现代的.NET Worker Service。本文将全面介绍C#中编写后台服务的各种方法、技术选型和最佳实践。

1. 后台服务类型选择

1.1 Windows服务（传统方式）

适用场景：

  • 需要在Windows服务器长期运行的后台任务
  • 需要随系统启动自动运行的服务
  • 不依赖用户登录状态的服务

特点：

  • 基于System.ServiceProcess.ServiceBase
  • 需要安装到服务管理器
  • 适合.NET Framework应用

1.2 Worker Service（现代方式）

适用场景：

  • .NET Core/.NET 5+应用
  • 需要跨平台支持的服务
  • 容器化部署的服务

特点：

  • 基于Microsoft.Extensions.Hosting
  • 可作为Windows服务或Linux守护进程运行
  • 与.NET通用主机模型集成

1.3 Web应用中的后台服务

适用场景：

  • 需要与Web应用共享进程的后台任务
  • 轻量级后台处理
  • 短期运行的任务

特点：

  • 在ASP.NET Core中使用IHostedService
  • 与Web应用生命周期绑定
  • 适合非关键性后台任务

2. Windows服务开发

2.1 创建Windows服务项目

using System.ServiceProcess;

public class MyWindowsService : ServiceBase
{
    private Timer _timer;

    public MyWindowsService()
    {
        ServiceName = "MyService";
        CanStop = true;
        CanPauseAndContinue = true;
        AutoLog = true;
    }

    protected override void OnStart(string[] args)
    {
        // 初始化资源
        _timer = new Timer(DoWork, null, TimeSpan.Zero, 
            TimeSpan.FromMinutes(5));

        EventLog.WriteEntry("服务已启动", EventLogEntryType.Information);
    }

    private void DoWork(object state)
    {
        try
        {
            // 执行后台工作
            EventLog.WriteEntry($"任务执行于 {DateTime.Now}", 
                EventLogEntryType.Information);
        }
        catch (Exception ex)
        {
            EventLog.WriteEntry($"任务失败: {ex.Message}", 
                EventLogEntryType.Error);
        }
    }

    protected override void OnStop()
    {
        _timer?.Dispose();
        EventLog.WriteEntry("服务已停止", EventLogEntryType.Information);
    }
}

// Program.cs
static class Program
{
    static void Main()
    {
        ServiceBase[] servicesToRun = new ServiceBase[] 
        { 
            new MyWindowsService() 
        };
        ServiceBase.Run(servicesToRun);
    }
}

2.2 安装和部署

使用InstallUtil：

InstallUtil.exe MyService.exe
InstallUtil.exe /u MyService.exe  # 卸载

使用SC命令：

sc create MyService binPath= "C:\path\to\MyService.exe" start= auto
sc start MyService
sc delete MyService

3. Worker Service开发（.NET Core+）

3.1 创建Worker Service项目

dotnet new worker -n MyBackgroundService

3.2 实现后台服务

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)
        {
            try
            {
                _logger.LogInformation("Worker running at: {time}", DateTimeOffset.Now);
                await DoWorkAsync(stoppingToken);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Worker encountered an error");
            }

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

    private async Task DoWorkAsync(CancellationToken token)
    {
        // 执行实际工作
        await Task.CompletedTask;
    }
}

3.3 配置主机

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

    public static IHostBuilder CreateHostBuilder(string[] args) =>
        Host.CreateDefaultBuilder(args)
            .UseWindowsService() // 作为Windows服务运行
            // .UseSystemd()    // Linux系统使用
            .ConfigureServices((hostContext, services) =>
            {
                services.AddHostedService<Worker>();

                // 添加其他服务
                services.AddSingleton<IMyService, MyService>();
            })
            .ConfigureLogging(logging =>
            {
                logging.AddEventLog(settings =>
                {
                    settings.SourceName = "MyBackgroundService";
                });
            });
}

4. Web应用中的后台服务

4.1 实现IHostedService

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

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

    public Task StartAsync(CancellationToken cancellationToken)
    {
        _logger.LogInformation("定时后台服务启动");
        _timer = new Timer(DoWork, null, TimeSpan.Zero, 
            TimeSpan.FromSeconds(30));
        return Task.CompletedTask;
    }

    private void DoWork(object state)
    {
        _logger.LogInformation("后台任务执行: {time}", DateTimeOffset.Now);
    }

    public Task StopAsync(CancellationToken cancellationToken)
    {
        _logger.LogInformation("定时后台服务停止");
        _timer?.Change(Timeout.Infinite, 0);
        return Task.CompletedTask;
    }

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

4.2 注册服务

public void ConfigureServices(IServiceCollection services)
{
    services.AddControllers();

    // 注册后台服务
    services.AddHostedService<TimedHostedService>();
}

5. 高级后台服务模式

5.1 使用消息队列的消费者服务

public class QueueConsumerService : BackgroundService
{
    private readonly ILogger<QueueConsumerService> _logger;
    private readonly IMessageQueue _queue;

    public QueueConsumerService(
        ILogger<QueueConsumerService> logger,
        IMessageQueue queue)
    {
        _logger = logger;
        _queue = queue;
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        await foreach (var message in _queue.GetMessagesAsync(stoppingToken))
        {
            try
            {
                _logger.LogInformation("Processing message: {id}", message.Id);
                await ProcessMessageAsync(message, stoppingToken);
                await _queue.CompleteAsync(message, stoppingToken);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error processing message: {id}", message.Id);
                await _queue.AbandonAsync(message, stoppingToken);
            }
        }
    }

    private async Task ProcessMessageAsync(QueueMessage message, CancellationToken token)
    {
        // 处理消息业务逻辑
        await Task.Delay(100, token); // 模拟工作
    }
}

5.2 并行任务处理

public class ParallelWorker : BackgroundService
{
    private readonly ILogger<ParallelWorker> _logger;
    private readonly SemaphoreSlim _semaphore = new SemaphoreSlim(5); // 最大并行度

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

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        var tasks = new List<Task>();

        while (!stoppingToken.IsCancellationRequested)
        {
            await _semaphore.WaitAsync(stoppingToken);

            tasks.Add(Task.Run(async () => 
            {
                try
                {
                    await DoWorkAsync(stoppingToken);
                }
                finally
                {
                    _semaphore.Release();
                }
            }, stoppingToken));

            await Task.Delay(1000, stoppingToken);
        }

        await Task.WhenAll(tasks);
    }

    private async Task DoWorkAsync(CancellationToken token)
    {
        _logger.LogInformation("开始处理工作项");
        await Task.Delay(2000, token); // 模拟工作
        _logger.LogInformation("工作项处理完成");
    }
}

6. 最佳实践

6.1 错误处理与恢复

protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
    while (!stoppingToken.IsCancellationRequested)
    {
        try
        {
            await DoWorkAsync(stoppingToken);
        }
        catch (OperationCanceledException)
        {
            // 正常取消
            break;
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "服务执行出错");

            // 指数退避重试
            await Task.Delay(
                CalculateRetryDelay(retryCount++), 
                stoppingToken);
        }
    }
}

private TimeSpan CalculateRetryDelay(int retryCount)
{
    return TimeSpan.FromSeconds(Math.Min(
        Math.Pow(2, retryCount), 
        maxDelaySeconds));
}

6.2 配置管理

public class ConfigurableWorker : BackgroundService
{
    private readonly ILogger<ConfigurableWorker> _logger;
    private readonly IConfiguration _config;
    private Timer _timer;

    public ConfigurableWorker(
        ILogger<ConfigurableWorker> logger,
        IConfiguration config)
    {
        _logger = logger;
        _config = config;
    }

    protected override Task ExecuteAsync(CancellationToken stoppingToken)
    {
        var interval = _config.GetValue<int>("Worker:IntervalSeconds");

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

        return Task.CompletedTask;
    }

    // 其他实现...
}

6.3 健康检查集成

public class HealthyWorker : BackgroundService, IHealthCheck
{
    private readonly ILogger<HealthyWorker> _logger;
    private bool _isHealthy = true;

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

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            try
            {
                await DoWorkAsync(stoppingToken);
                _isHealthy = true;
            }
            catch (Exception ex)
            {
                _isHealthy = false;
                _logger.LogError(ex, "工作失败");
            }

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

    public Task<HealthCheckResult> CheckHealthAsync(
        HealthCheckContext context,
        CancellationToken cancellationToken = default)
    {
        return Task.FromResult(_isHealthy 
            ? HealthCheckResult.Healthy("Worker is healthy")
            : HealthCheckResult.Unhealthy("Worker is not healthy"));
    }
}

7. 部署与运维

7.1 作为Windows服务发布

dotnet publish -c Release -o ./publish
sc create MyService binPath= "C:\path\to\publish\MyBackgroundService.exe"

7.2 作为Linux守护进程

sudo nano /etc/systemd/system/myworker.service

# 文件内容示例
[Unit]
Description=My .NET Worker Service

[Service]
WorkingDirectory=/var/www/myworker
ExecStart=/usr/bin/dotnet /var/www/myworker/MyBackgroundService.dll
Restart=always
RestartSec=10

[Install]
WantedBy=multi-user.target

# 启用服务
sudo systemctl enable myworker
sudo systemctl start myworker

7.3 容器化部署

FROM mcr.microsoft.com/dotnet/runtime:6.0 AS base
WORKDIR /app

FROM mcr.microsoft.com/dotnet/sdk:6.0 AS build
WORKDIR /src
COPY ["MyBackgroundService.csproj", "."]
RUN dotnet restore "MyBackgroundService.csproj"
COPY . .
RUN dotnet build "MyBackgroundService.csproj" -c Release -o /app/build

FROM build AS publish
RUN dotnet publish "MyBackgroundService.csproj" -c Release -o /app/publish

FROM base AS final
WORKDIR /app
COPY --from=publish /app/publish .
ENTRYPOINT ["dotnet", "MyBackgroundService.dll"]

结语

C#提供了丰富而灵活的后台服务开发选项，从传统的Windows服务到现代的Worker Service模式，开发者可以根据应用场景、部署环境和功能需求选择最适合的实现方式。无论选择哪种技术路径，都应当遵循良好的设计原则，实现可靠的错误处理、合理的资源管理和完善的可观测性。通过结合.NET生态系统的强大功能，如依赖注入、配置管理和健康检查，可以构建出既健壮又易于维护的后台服务。

a_a_a

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注