C# Academy · Aula

Projetos de Worker Service

Crie um Worker Service independente, configure DI e logging e implante-o como um serviço do Windows ou daemon do Linux.

Projetos de Worker Service é uma aula grátis de C# Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de C# Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de C# Academy inclui 4 aulas no total.

O que é um Worker Service

Um Worker Service é um modelo de projeto do .NET para criar aplicativos em segundo plano de longa duração — sem servidor web e sem pontos de extremidade HTTP. Ele é um hospedeiro leve, perfeito para processadores de filas, tarefas agendadas e serviços no estilo de daemon.

Criando um Worker Service

Use o modelo da CLI para gerar a estrutura de um projeto Worker Service. Ele gera um Program.cs mínimo e uma classe Worker.cs que herda de BackgroundService.

# Create a new Worker Service project
dotnet new worker -n OrderProcessor

# Generated structure:
# OrderProcessor/
#   Program.cs       — host configuration
#   Worker.cs        — your BackgroundService subclass
#   appsettings.json

Program.cs do Worker Service

O Program.cs gerado usa o hospedeiro genérico. Você configura DI, registro em log, configuração e registra seu trabalhador — de forma idêntica ao ASP.NET Core, mas sem o servidor web.

using Microsoft.Extensions.Hosting;

var builder = Host.CreateApplicationBuilder(args);

// Register services
builder.Services.AddDbContext<AppDbContext>(opt =>
    opt.UseSqlServer(builder.Configuration.GetConnectionString("Default")));

builder.Services.AddScoped<IOrderRepository, OrderRepository>();
builder.Services.AddHostedService<OrderProcessorWorker>();

var host = builder.Build();
host.Run();

A classe Worker

Herede de BackgroundService e implemente ExecuteAsync. O hospedeiro o chama na inicialização e fornece um token de cancelamento que é disparado durante o desligamento.

public class OrderProcessorWorker : BackgroundService
{
    private readonly IServiceScopeFactory _factory;
    private readonly ILogger<OrderProcessorWorker> _logger;

    public OrderProcessorWorker(
        IServiceScopeFactory factory,
        ILogger<OrderProcessorWorker> logger)
    {
        _factory = factory;
        _logger  = logger;
    }

    protected override async Task ExecuteAsync(CancellationToken ct)
    {
        while (!ct.IsCancellationRequested)
        {
            using var scope = _factory.CreateScope();
            var repo = scope.ServiceProvider.GetRequiredService<IOrderRepository>();
            var pending = await repo.GetPendingAsync(ct);
            foreach (var order in pending)
                await ProcessOrderAsync(order, ct);
            await Task.Delay(TimeSpan.FromSeconds(10), ct);
        }
    }

    private Task ProcessOrderAsync(Order o, CancellationToken ct) =>
        Task.Delay(100, ct); // placeholder
}

Configuração e DI em trabalhadores

Os Worker Services oferecem suporte ao sistema completo de configuração do .NET — configurações do aplicativo, variáveis de ambiente e segredos do usuário. Injete IConfiguration ou opções fortemente tipadas.

builder.Services.Configure<WorkerSettings>(
    builder.Configuration.GetSection("Worker"));

public class OrderProcessorWorker : BackgroundService
{
    private readonly WorkerSettings _settings;

    public OrderProcessorWorker(IOptions<WorkerSettings> opts, ...)
        => _settings = opts.Value;

    protected override async Task ExecuteAsync(CancellationToken ct)
    {
        while (!ct.IsCancellationRequested)
        {
            // ...
            await Task.Delay(_settings.PollIntervalSeconds * 1000, ct);
        }
    }
}

Registro em log nos Worker Services

O hospedeiro genérico configura o registro em log automaticamente. Use ILogger<T> para registro em log estruturado. Em produção, configure Serilog, Application Insights ou outro provedor.

// Add Serilog to a Worker Service
builder.Host.UseSerilog((ctx, logConfig) =>
    logConfig
        .ReadFrom.Configuration(ctx.Configuration)
        .WriteTo.Console()
        .WriteTo.Seq(ctx.Configuration["Seq:ServerUrl"]!));

// Structured logging in the worker:
_logger.LogInformation("Processing {Count} orders at {Time}",
    orders.Count, DateTimeOffset.UtcNow);
_logger.LogError(ex, "Failed to process order {OrderId}", order.Id);

Executando como um serviço do Windows

Use UseWindowsService() para executar seu Worker como um serviço do Windows. O serviço inicia e para junto com o sistema operacional e continua ativo após o encerramento da sessão dos usuários.

// dotnet add package Microsoft.Extensions.Hosting.WindowsServices

builder.Services.AddWindowsService(options =>
    options.ServiceName = "OrderProcessor");

// Build and publish:
// dotnet publish -c Release -o ./publish

// Install as Windows Service:
// sc create OrderProcessor binpath="C:\services\publish\OrderProcessor.exe"
// sc start OrderProcessor

Executando como um daemon Systemd do Linux

Use UseSystemd() para integrar-se ao systemd no Linux. O serviço recebe sinais de parada adequados e integra-se ao registro em log do journald.

// dotnet add package Microsoft.Extensions.Hosting.Systemd

builder.Services.AddSystemd();

// Systemd unit file: /etc/systemd/system/orderprocessor.service
// [Unit]
// Description=Order Processor Worker
// [Service]
// Type=notify
// ExecStart=/usr/bin/dotnet /app/OrderProcessor.dll
// Restart=always
// [Install]
// WantedBy=multi-user.target

// Commands:
// sudo systemctl enable orderprocessor
// sudo systemctl start orderprocessor
// sudo journalctl -u orderprocessor -f

Executando no Docker

Os Worker Services são ideais para contêineres Docker — não é necessário mapear portas; basta executar o processo em um loop até o contêiner parar.

# Dockerfile
FROM mcr.microsoft.com/dotnet/sdk:9.0 AS build
WORKDIR /src
COPY . .
RUN dotnet publish -c Release -o /app

FROM mcr.microsoft.com/dotnet/runtime:9.0
WORKDIR /app
COPY --from=build /app .
ENTRYPOINT ["dotnet", "OrderProcessor.dll"]

# docker-compose.yml:
# services:
#   worker:
#     build: .
#     environment:
#       - ConnectionStrings__Default=Server=db;...
#     depends_on: [db]

Exemplo real: trabalhador de resumos de e-mail

Um trabalhador completo que envia resumos diários de e-mail lendo dados de um banco de dados e encaminhando-os por meio de um serviço de e-mail.

public class EmailDigestWorker : BackgroundService
{
    private readonly IServiceScopeFactory _factory;
    private readonly ILogger<EmailDigestWorker> _log;

    protected override async Task ExecuteAsync(CancellationToken ct)
    {
        // Run daily at midnight UTC
        while (!ct.IsCancellationRequested)
        {
            var now = DateTime.UtcNow;
            var next = now.Date.AddDays(1); // next midnight
            await Task.Delay(next - now, ct);

            using var scope = _factory.CreateScope();
            var mailer = scope.ServiceProvider.GetRequiredService<IDigestMailer>();

            try   { await mailer.SendDailyDigestsAsync(ct); }
            catch (Exception ex) { _log.LogError(ex, "Digest failed"); }
        }
    }
}

Verificação rápida

Qual é a principal diferença entre um projeto Worker Service e um projeto ASP.NET Core Web API?

Recapitulação: projetos Worker Service

Principais conclusões:

Worker Service = hospedeiro genérico + BackgroundService, sem servidor web
Suporte completo a DI, registro em log e configuração — apenas sem HTTP
UseWindowsService() para implantação como serviço do Windows
UseSystemd() para daemon do Linux com integração ao journald
Implante em contêineres Docker para processamento em segundo plano nativo da nuvem
Sempre use IServiceScopeFactory para dependências com escopo no trabalhador

Perguntas Frequentes

A aula “Projetos de Worker Service” é grátis?

Sim — o texto completo de “Projetos de Worker Service” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de C# Academy, atualize para CoddyKit PRO. O curso de C# Academy inclui 4 aulas no total.

O que vou aprender em “Projetos de Worker Service”?

Crie um Worker Service independente, configure DI e logging e implante-o como um serviço do Windows ou daemon do Linux. Você pratica C# Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar C# Academy?

Nenhuma experiência prévia é necessária. C# Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Projetos de Worker Service”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de C# Academy?

Sim. Cada aula de C# Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para C# Academy