D34.BackgroundServices 1.0.0

Background Services

Uma solução para processamento de tarefas em segundo plano (background jobs) utilizando Hangfire com .NET, seguindo princípios de Clean Architecture.

Estrutura do Projeto (Clean Architecture)

A solução está organizada seguindo princípios de Clean Architecture:

• Core:
  • Domain: Entidades, interfaces de repositórios e regras de negócio puras.
  • Application: Casos de uso, serviços de aplicação e interfaces.
  • Infrastructure: Implementações concretas (Hangfire, bancos de dados, etc).
  • Presentation: Components de UI reutilizáveis (extensões para dashboard, etc).
• Api: API de exemplo que mostra como utilizar o pacote Core em uma aplicação ASP.NET.
• Tests: Projetos de testes para validar as diferentes camadas da aplicação.

Padrões de Projeto Utilizados

• Repository Pattern: Para abstração do acesso a dados
• Decorator Pattern: Para adicionar funcionalidades cross-cutting (como logging) aos jobs
• Strategy Pattern: Para escolher diferentes implementações de execução de jobs
• Factory Pattern: Para criação de jobs
• Adapter Pattern: Para adaptar a API do Hangfire para nossa interface de domínio
• Dependency Injection: Para manter baixo acoplamento entre componentes

Características Principais

Core

• Implementação limpa seguindo princípios SOLID
• Camadas bem definidas com responsabilidades claras
• Suporte para todos os tipos de jobs do Hangfire:
  • Fire-and-forget (execução imediata)
  • Agendados (delayed)
  • Recorrentes (recurring)
  • Continuações (continuations)
• Implementações com suporte a async/await
• Independência de frameworks (domínio)
• Altamente testável

API de Exemplo

A API de exemplo demonstra todos os cenários possíveis:

• Enfileirar jobs para execução imediata
• Agendar jobs para execução futura
• Configurar jobs recorrentes com expressões cron
• Encadear jobs para execução sequencial
• Cancelar/remover jobs

Como Usar

Configuração

Para usar este pacote em seu projeto, configure-o no Program.cs ou Startup.cs:

// Adicionar serviços do Hangfire usando a configuração no appsettings.json
builder.Services.AddHangfireServices(builder.Configuration);

// Ou com configuração explícita:
var hangfireOptions = new HangfireOptions
{
    ConnectionString = "Server=(localdb)\\mssqllocaldb;Database=HangfireDemo;Trusted_Connection=True;",
    WorkerCount = 5,
    JobExpirationInDays = 7
};
builder.Services.AddHangfireServices(hangfireOptions);

E adicione o dashboard:

app.UseHangfireDashboard(hangfireOptions);

Criação de Jobs

1. Crie uma interface de serviço na camada Application:

namespace MeuProjeto.Application.Jobs;

public interface IMyJobService
{
    void ProcessData(string data);
    Task SendEmailAsync(string to, string subject, string body);
}

2. Implemente o serviço:

namespace MeuProjeto.Application.Jobs;

public class MyJobService : IMyJobService
{
    private readonly ILogger<MyJobService> _logger;
    
    public MyJobService(ILogger<MyJobService> logger)
    {
        _logger = logger;
    }
    
    public void ProcessData(string data)
    {
        // Lógica para processar dados
        _logger.LogInformation("Processando dados: {Data}", data);
    }

    public async Task SendEmailAsync(string to, string subject, string body)
    {
        // Lógica para enviar emails
        _logger.LogInformation("Enviando email para: {To}, Assunto: {Subject}", to, subject);
        await Task.Delay(100); // Simulação de operação assíncrona
    }
}

3. Registre o serviço:

services.AddScoped<IMyJobService, MyJobService>();

4. Use o IBackgroundJobService para agendar jobs:

// Enfileirar job para execução imediata
_backgroundJobService.Enqueue<IMyJobService>(x => x.ProcessData("sample data"));

// Agendar job para execução futura
_backgroundJobService.Schedule<IMyJobService>(
    x => x.SendEmailAsync("user@example.com", "Test", "This is a test"),
    TimeSpan.FromMinutes(5));

// Configurar job recorrente
_backgroundJobService.AddOrUpdateRecurringJob<IMyJobService>(
    "daily-report",
    x => x.SendEmailAsync("admin@example.com", "Daily Report", "..."),
    "0 0 * * *"); // Todos os dias à meia-noite

// Encadear jobs
var jobId = _backgroundJobService.Enqueue<IMyJobService>(x => x.ProcessData("step 1"));
_backgroundJobService.ContinueJobWith<IMyJobService>(jobId, x => x.ProcessData("step 2"));

Benefícios da Clean Architecture

1. Manutenção facilitada: A separação clara de responsabilidades torna o código mais fácil de manter.
2. Testabilidade: Camadas independentes permitem testes isolados.
3. Flexibilidade: É possível trocar implementações específicas sem afetar o restante do sistema.
4. Independência de frameworks: O domínio da aplicação não depende de frameworks externos.
5. Evolução independente: Cada camada pode evoluir sem impactar as outras.