Adapter Pattern em C# com Injeção de Dependência e Worker Service

#csharp #designpatterns #dotnet

🚀 Aplicando o Adapter Pattern em C# com Injeção de Dependência e Worker Service

📌 Introdução

Ao trabalhar com sistemas legados, é comum encontrar APIs ou serviços que não seguem as interfaces modernas do nosso código. Em vez de modificar diretamente esses sistemas, podemos usar o Adapter Pattern para fazer a integração de forma elegante.

Neste artigo, vou mostrar como implementar o Adapter Pattern em C#, usando Injeção de Dependência (DI) e um Worker Service para simular um processo contínuo.

🎯 O que é o Adapter Pattern?

O Adapter Pattern é um padrão estrutural que permite que objetos com interfaces incompatíveis trabalhem juntos. Ele age como um intermediário, convertendo a interface de uma classe para outra esperada pelo sistema.

📌 Quando usar?

✅ Quando precisamos integrar APIs ou bibliotecas legadas que não podem ser alteradas.
✅ Quando queremos manter um código desacoplado e flexível.
✅ Quando temos diferentes implementações que precisam seguir um mesmo contrato.

🛠️ Implementação

Vamos construir um exemplo onde temos um sistema de pagamentos legados e queremos integrá-lo a um Worker Service que processa pagamentos periodicamente.

🏗️ 1️⃣ Criamos a interface moderna IPaymentProcessor

public interface IPaymentProcessor
{
    void ProcessPayment(decimal amount);
}

🏗️ 2️⃣ Criamos o serviço legado LegacyPaymentService

Este é um serviço que já existe e que queremos reutilizar, mas ele usa uma interface diferente.

public sealed class LegacyPaymentService
{
    public void MakePayment(string amount)
    {
        Console.WriteLine($"Processing payment of {amount} via legacy system.");
    }
}

🏗️ 3️⃣ Criamos o Adapter PaymentAdapter

Aqui adaptamos LegacyPaymentService para seguir a interface IPaymentProcessor.

public sealed class PaymentAdapter : IPaymentProcessor
{
    private readonly LegacyPaymentService _legacyPaymentService;

    public PaymentAdapter(LegacyPaymentService legacyPaymentService)
    {
        _legacyPaymentService = legacyPaymentService;
    }

    public void ProcessPayment(decimal amount)
    {
        string amountString = amount.ToString("F2");
        _legacyPaymentService.MakePayment(amountString);
    }
}

🏗️ 4️⃣ Criamos o Worker Service PaymentWorker

Nosso Worker será responsável por chamar o IPaymentProcessor periodicamente.

using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using System;
using System.Threading;
using System.Threading.Tasks;

public class PaymentWorker : BackgroundService
{
    private readonly ILogger<PaymentWorker> _logger;
    private readonly IPaymentProcessor _paymentProcessor;

    public PaymentWorker(ILogger<PaymentWorker> logger, IPaymentProcessor paymentProcessor)
    {
        _logger = logger;
        _paymentProcessor = paymentProcessor;
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            _logger.LogInformation("Iniciando processamento de pagamento...");

            _paymentProcessor.ProcessPayment(100.50m); // Simulando pagamento de R$100,50

            _logger.LogInformation("Pagamento processado com sucesso!");

            await Task.Delay(5000, stoppingToken); // Executa a cada 5 segundos
        }
    }
}

🏗️ 5️⃣ Configuramos a Injeção de Dependência no Host

Agora precisamos configurar os serviços no Host do Worker Service.

using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;

class Program
{
    static void Main(string[] args)
    {
        var host = Host.CreateDefaultBuilder(args)
            .ConfigureServices((hostContext, services) =>
            {
                services.AddSingleton<LegacyPaymentService>(); // Serviço legado
                services.AddSingleton<IPaymentProcessor, PaymentAdapter>(); // Adapter
                services.AddHostedService<PaymentWorker>(); // Worker Service
                services.AddLogging(); // Logs
            })
            .Build();

        host.Run();
    }
}

✅ O que aprendemos?

✔ Como usar o Adapter Pattern para conectar serviços legados a um código moderno.
✔ Como estruturar Injeção de Dependência (DI) para desacoplar o código.
✔ Como criar um Worker Service que processa tarefas periodicamente.

🚀 Conclusão

O Adapter Pattern é uma solução poderosa para integrar serviços sem alterar o código legado. Combinado com Injeção de Dependência e Worker Services, ele nos permite construir sistemas escaláveis e bem estruturados.

E você? Já usou esse padrão em algum projeto? Deixe um comentário! 🚀

DEV Community

Adapter Pattern em C# com Injeção de Dependência e Worker Service

Top comments (0)