Padrões GoF: Código à Nuvem, Monólito ao Microserviço

1
2
3
4

Ano 1: "Vamos colocar lógica de negócio diretamente no controller, é mais rápido"
Ano 2: "Temos 300 controllers com 500 linhas cada, impossível testar"
Ano 3: "Precisamos de 6 meses para migrar para qualquer outra coisa"
Ano 4: "Não conseguimos contratar seniors porque ninguém quer trabalhar nesse código"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

// Independente de linguagem — o princípio:
// "Quero criar algo, mas não quero saber COMO é criado"

public abstract class NotificadorBase
{
    // Factory Method: subclasses definem qual canal usar
    protected abstract ICanal CriarCanal();

    public void Notificar(string mensagem)
    {
        var canal = CriarCanal();  // criação delegada à subclass
        canal.Enviar(mensagem);
    }
}

public class NotificadorEmail : NotificadorBase
{
    protected override ICanal CriarCanal() => new CanalEmail();
}

public class NotificadorSms : NotificadorBase
{
    protected override ICanal CriarCanal() => new CanalSms();
}

// O código de orquestração não precisa saber qual canal é usado:
NotificadorBase notificador = ambiente == "prod"
    ? new NotificadorEmail()
    : new NotificadorSms();
notificador.Notificar("Pedido confirmado");

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

// Problema: você precisa de componentes que sejam consistentes entre si (mesma "família")
// Exemplo: componentes de UI que devem ser todos "Light" ou todos "Dark"

public interface IUiFactory
{
    IBotao CriarBotao();
    IInput CriarInput();
    ICard CriarCard();
}

public class LightThemeFactory : IUiFactory
{
    public IBotao CriarBotao() => new BotaoLight();
    public IInput CriarInput() => new InputLight();
    public ICard CriarCard() => new CardLight();
}

public class DarkThemeFactory : IUiFactory
{
    public IBotao CriarBotao() => new BotaoDark();
    public IInput CriarInput() => new InputDark();
    public ICard CriarCard() => new CardDark();
}

// A tela usa a factory — nunca instancia diretamente:
public class TelaCheckout(IUiFactory factory)
{
    private readonly IBotao _btnConfirmar = factory.CriarBotao();
    private readonly IInput _inputCartao   = factory.CriarInput();
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

// Resolve o "telescoping constructor" problem:
// Em vez de: new Pedido(1, "João", true, false, null, 0, "SP", "BR", ...)
// Use:

var pedido = new PedidoBuilder()
    .ParaCliente(clienteId: 1)
    .ComItem(produtoId: 10, quantidade: 2)
    .ComItem(produtoId: 15, quantidade: 1)
    .ComDesconto(10)
    .ComEnderecoEntrega("Rua A", "São Paulo", "SP")
    .ComPrioridadeExpressa()
    .Build();

public class PedidoBuilder
{
    private readonly Pedido _pedido = new();

    public PedidoBuilder ParaCliente(int clienteId)
        { _pedido.ClienteId = clienteId; return this; }

    public PedidoBuilder ComItem(int produtoId, int quantidade)
        { _pedido.Itens.Add(new Item(produtoId, quantidade)); return this; }

    public PedidoBuilder ComDesconto(decimal percentual)
        { _pedido.Desconto = percentual; return this; }

    public PedidoBuilder ComPrioridadeExpressa()
        { _pedido.Prioridade = PrioridadePedido.Expressa; return this; }

    public Pedido Build()
    {
        _pedido.Validar();  // validação centralizada no Build
        return _pedido;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

// Útil quando criar do zero é caro (consulta ao banco, inicialização pesada)
public abstract class Componente
{
    public abstract Componente Clone();
    public string Nome { get; set; } = "";
    public Dictionary<string, string> Configuracoes { get; set; } = [];
}

public class ComponenteNginx : Componente
{
    public override Componente Clone()
    {
        var clone = (ComponenteNginx)MemberwiseClone();
        // Deep copy das configurações mutáveis
        clone.Configuracoes = new Dictionary<string, string>(Configuracoes);
        return clone;
    }
}

// Em vez de criar e configurar do zero toda vez:
var templateNginx = new ComponenteNginx { Nome = "nginx-template" };
templateNginx.Configuracoes["porta"] = "80";
templateNginx.Configuracoes["workers"] = "4";

// Clonar é muito mais barato:
var nginx1 = (ComponenteNginx)templateNginx.Clone();
nginx1.Nome = "nginx-producao";

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

// Em .NET moderno, prefira injeção de dependência com Lifetime.Singleton
// mas o padrão ainda é relevante para entender o conceito:

// ⚠️ Thread-safe com Lazy<T> (mais idiomático em .NET):
public sealed class GerenciadorCache
{
    private static readonly Lazy<GerenciadorCache> _instancia =
        new(() => new GerenciadorCache());

    private GerenciadorCache() { }  // construtor privado

    public static GerenciadorCache Instancia => _instancia.Value;

    public object? Obter(string chave) { /* ... */ return null; }
    public void Definir(string chave, object valor) { /* ... */ }
}

// Uso:
GerenciadorCache.Instancia.Definir("config", dados);

// ✅ Em ASP.NET Core: use services.AddSingleton<IGerenciadorCache, GerenciadorCache>()
// O contêiner de DI garante a única instância com thread-safety

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

// Problema clássico: nova SDK de pagamento com interface diferente da atual
public interface IGatewayPagamento  // interface que SEU sistema espera
{
    Task<ResultadoPagamento> ProcessarAsync(DadosPagamento dados);
}

// Classe existente de terceiro com interface diferente:
public class StripeClient  // você NÃO controla essa classe
{
    public StripeResult Charge(string token, long amountCents, string currency)
        { /* Stripe SDK */ return new StripeResult(); }
}

// Adapter: adapta a interface do Stripe para a interface esperada pelo sistema
public class StripeAdapter(StripeClient stripe) : IGatewayPagamento
{
    public async Task<ResultadoPagamento> ProcessarAsync(DadosPagamento dados)
    {
        var resultado = await Task.Run(() =>
            stripe.Charge(dados.Token, (long)(dados.Valor * 100), dados.Moeda));

        return new ResultadoPagamento(
            Sucesso: resultado.Status == "succeeded",
            TransacaoId: resultado.Id);
    }
}

// O sistema nunca sabe que está usando Stripe:
IGatewayPagamento gateway = new StripeAdapter(new StripeClient());
await gateway.ProcessarAsync(dadosDoPedido);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

// O poder real: compor comportamentos sem explodir a hierarquia de herança

public interface IRepositorioPedidos
{
    Task<Pedido?> ObterAsync(int id);
    Task SalvarAsync(Pedido pedido);
}

// Decorator 1: adiciona cache
public class PedidosComCache(IRepositorioPedidos inner, ICache cache)
    : IRepositorioPedidos
{
    public async Task<Pedido?> ObterAsync(int id)
    {
        var cached = await cache.GetAsync<Pedido>($"pedido:{id}");
        if (cached is not null) return cached;

        var pedido = await inner.ObterAsync(id);
        if (pedido is not null)
            await cache.SetAsync($"pedido:{id}", pedido, TimeSpan.FromMinutes(5));
        return pedido;
    }

    public Task SalvarAsync(Pedido pedido) => inner.SalvarAsync(pedido);
}

// Decorator 2: adiciona logging
public class PedidosComLogging(IRepositorioPedidos inner, ILogger logger)
    : IRepositorioPedidos
{
    public async Task<Pedido?> ObterAsync(int id)
    {
        logger.LogInformation("Buscando pedido {Id}", id);
        var result = await inner.ObterAsync(id);
        logger.LogInformation("Pedido {Id}: {Status}", id, result is null ? "não encontrado" : "encontrado");
        return result;
    }

    public Task SalvarAsync(Pedido pedido) => inner.SalvarAsync(pedido);
}

// Composition root — você empilha os decorators como quiser:
IRepositorioPedidos repo =
    new PedidosComLogging(
        new PedidosComCache(
            new PedidosEfCore(dbContext),
            redisCache),
        logger);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

// Problema: finalizar um pedido envolve 6 subsistemas diferentes
// Sem Facade: cada controller conhece e orquestra todos os subsistemas

// Com Facade: um único ponto de entrada para o caso de uso
public class ServicoFinalizacaoPedido(
    IEstoqueService estoque,
    IFinanceiroService financeiro,
    ILogisticaService logistica,
    INotificacaoService notificacao,
    IAuditService auditoria)
{
    public async Task<ResultadoFinalizacao> FinalizarAsync(int pedidoId)
    {
        // Orquestra a complexidade internamente
        await estoque.ReservarItensAsync(pedidoId);
        var cobranca = await financeiro.CobrarAsync(pedidoId);

        if (!cobranca.Aprovada)
        {
            await estoque.LiberarReservaAsync(pedidoId);
            return ResultadoFinalizacao.FalhaNoPagamento(cobranca.Motivo);
        }

        var envio = await logistica.AgendarEnvioAsync(pedidoId);
        await notificacao.NotificarClienteAsync(pedidoId, envio.PrevisaoEntrega);
        await auditoria.RegistrarAsync(pedidoId, "PEDIDO_FINALIZADO");

        return ResultadoFinalizacao.Sucesso(cobranca.TransacaoId, envio.CodigoRastreio);
    }
}

// Controller: limpo, sem complexidade de orquestração:
[HttpPost("{id}/finalizar")]
public async Task<IActionResult> Finalizar(int id)
{
    var resultado = await _servico.FinalizarAsync(id);
    return resultado.Sucesso ? Ok(resultado) : BadRequest(resultado);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

// Proxy virtual: carrega dados sob demanda (lazy loading)
// Proxy de proteção: verifica permissões antes de delegar
// Proxy remoto: abstrai comunicação de rede

// Proxy de proteção:
public class RepositorioPedidosProtegido(
    IRepositorioPedidos inner,
    IHttpContextAccessor httpContext) : IRepositorioPedidos
{
    public async Task<Pedido?> ObterAsync(int id)
    {
        var usuario = httpContext.HttpContext?.User;

        if (usuario?.IsInRole("Admin") != true)
        {
            // Restringe acesso ao pedido do próprio usuário
            var pedido = await inner.ObterAsync(id);
            var userId = usuario?.FindFirst("sub")?.Value;
            return pedido?.ClienteId.ToString() == userId ? pedido : null;
        }

        return await inner.ObterAsync(id);
    }

    public Task SalvarAsync(Pedido pedido) => inner.SalvarAsync(pedido);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

// Contexto: calcular frete com diferentes transportadoras
public interface ICalculadorFrete
{
    decimal Calcular(Endereco origem, Endereco destino, decimal pesoKg);
}

public class FreteCorreios : ICalculadorFrete
{
    public decimal Calcular(Endereco origem, Endereco destino, decimal pesoKg)
        => /* lógica dos Correios */ pesoKg * 3.5m + 8.0m;
}

public class FreteTransportadora : ICalculadorFrete
{
    public decimal Calcular(Endereco origem, Endereco destino, decimal pesoKg)
        => /* lógica da transportadora */ pesoKg * 2.8m + 15.0m;
}

public class FreteRetiradaLoja : ICalculadorFrete
{
    public decimal Calcular(Endereco origem, Endereco destino, decimal pesoKg)
        => 0m;  // grátis na retirada
}

// Context: usa a estratégia sem saber qual é
public class Carrinho(ICalculadorFrete calculadorFrete)
{
    public decimal CalcularFrete(Endereco destino)
        => calculadorFrete.Calcular(_enderecoLoja, destino, _pesoTotal);
}

// Flexibilidade na composição:
var carrinho = new Carrinho(cliente.PrefereFreteProprio
    ? new FreteTransportadora()
    : new FreteCorreios());

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

// Base para sistemas de eventos, reactive programming, pub/sub
// .NET tem IObservable<T>/IObserver<T> nativos que seguem esse padrão

public interface IObservadorPedido
{
    Task AoAtualizarAsync(Pedido pedido);
}

public class ServicoPedidos
{
    private readonly List<IObservadorPedido> _observadores = [];

    public void Inscrever(IObservadorPedido obs) => _observadores.Add(obs);
    public void Cancelar(IObservadorPedido obs) => _observadores.Remove(obs);

    public async Task AtualizarStatusAsync(int id, StatusPedido novoStatus)
    {
        var pedido = await _repo.ObterAsync(id);
        pedido.Status = novoStatus;
        await _repo.SalvarAsync(pedido);

        // Notifica todos os observadores
        foreach (var obs in _observadores)
            await obs.AoAtualizarAsync(pedido);
    }
}

// Observadores registrados:
var servico = new ServicoPedidos(repo);
servico.Inscrever(new NotificadorEmailCliente(emailService));
servico.Inscrever(new AtualizadorEstoque(estoqueService));
servico.Inscrever(new RegistradorAuditoria(auditService));
servico.Inscrever(new GatewayWebhook(webhookService));

// Em .NET moderno: MediatR + domain events implementam exatamente este padrão

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

// O padrão Command está no coração de CQRS, event sourcing e undo/redo

public interface IComando<TResultado> { }

public record CancelarPedidoComando(int PedidoId, string Motivo)
    : IComando<ResultadoCancelamento>;

public class CancelarPedidoHandler(
    IRepositorioPedidos repo,
    IEventBus eventBus,
    IAuditService auditoria)
    : IHandlerComando<CancelarPedidoComando, ResultadoCancelamento>
{
    public async Task<ResultadoCancelamento> ExecutarAsync(CancelarPedidoComando cmd)
    {
        var pedido = await repo.ObterAsync(cmd.PedidoId)
            ?? throw new PedidoNaoEncontradoException(cmd.PedidoId);

        if (!pedido.PodeCancelar())
            return ResultadoCancelamento.Falha("Status não permite cancelamento");

        pedido.Cancelar(cmd.Motivo);
        await repo.SalvarAsync(pedido);

        // Publica evento para outros serviços (Observer + Command combinados)
        await eventBus.PublicarAsync(new PedidoCanceladoEvent(pedido.Id, cmd.Motivo));
        await auditoria.RegistrarAsync(pedido.Id, "PEDIDO_CANCELADO", cmd.Motivo);

        return ResultadoCancelamento.Sucesso();
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

// EventEmitter do Node.js é um Observer nativo
const { EventEmitter } = require('events');
class ServicoPedidos extends EventEmitter {
  async cancelar(id, motivo) {
    /* ... */
    this.emit('pedidoCancelado', { id, motivo });
  }
}
const svc = new ServicoPedidos();
svc.on('pedidoCancelado', ({ id }) => notificarCliente(id));
svc.on('pedidoCancelado', ({ id }) => atualizarEstoque(id));

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

from abc import ABC, abstractmethod

class CalculadorFrete(ABC):
    @abstractmethod
    def calcular(self, peso: float) -> float: ...

class FreteCorreios(CalculadorFrete):
    def calcular(self, peso: float) -> float:
        return peso * 3.5 + 8.0

class Carrinho:
    def __init__(self, calculador: CalculadorFrete):
        self._calculador = calculador  # Strategy injetada

1
2
3
4
5
6
7
8
9

type Notificador interface { Enviar(msg string) error }

func NovoNotificador(tipo string) Notificador {
    switch tipo {
    case "email": return &NotificadorEmail{}
    case "sms":   return &NotificadorSms{}
    default:      return &NotificadorLog{}
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

// Polly implementa Circuit Breaker em .NET:
var pipeline = new ResiliencePipelineBuilder()
    .AddCircuitBreaker(new CircuitBreakerStrategyOptions
    {
        FailureRatio = 0.5,          // 50% de falhas → abre o disjuntor
        SamplingDuration = TimeSpan.FromSeconds(30),
        BreakDuration = TimeSpan.FromSeconds(15),
        OnOpened = args =>
        {
            logger.LogWarning("Circuit breaker ABERTO para serviço de pagamentos");
            return ValueTask.CompletedTask;
        }
    })
    .Build();

await pipeline.ExecuteAsync(async ct =>
    await gatewayPagamentos.ProcessarAsync(dados, ct));

1
2
3
4
5
6
7
8
9

# Kubernetes: sidecar de logging (padrão Decorator em nível de pod)
spec:
  containers:
  - name: api-pedidos          # container principal
    image: api-pedidos:1.2
  - name: fluent-bit           # sidecar: coleta e envia logs
    image: fluent/fluent-bit
    volumeMounts:
    - mountPath: /var/log/pods

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

// Saga orquestrada com MassTransit:
// 1. Reservar estoque          → se falhar → compensar: nada
// 2. Cobrar pagamento          → se falhar → compensar: liberar reserva
// 3. Agendar envio             → se falhar → compensar: estornar + liberar
// 4. Notificar cliente         → se falhar → compensar: log (não crítico)

public class FinalizarPedidoSaga : MassTransitStateMachine<FinalizarPedidoState>
{
    public State Reservando { get; private set; } = null!;
    public State Cobrando { get; private set; } = null!;
    public State Enviando { get; private set; } = null!;

    public FinalizarPedidoSaga()
    {
        Initially(
            When(PedidoFinalizado)
                .Then(ctx => ctx.Saga.PedidoId = ctx.Message.PedidoId)
                .TransitionTo(Reservando)
                .Publish(ctx => new ReservarEstoqueCommand(ctx.Saga.PedidoId)));

        During(Reservando,
            When(EstoqueReservado)
                .TransitionTo(Cobrando)
                .Publish(ctx => new CobrarPagamentoCommand(ctx.Saga.PedidoId)),
            When(EstoqueFalhou)
                .Publish(ctx => new PedidoCanceladoEvent(ctx.Saga.PedidoId, "Sem estoque"))
                .Finalize());
        // ...
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

// Segregar leitura de escrita permite otimizações independentes
// Escrita: consistência forte, validações, eventos de domínio
// Leitura: desnormalização, cache, read replicas, projeções

// Command side (escrita):
public record CriarPedidoCommand(int ClienteId, List<ItemDto> Itens)
    : ICommand<PedidoCriadoResult>;

// Query side (leitura — sem entidades de domínio, direto ao banco de leitura):
public record ListarPedidosQuery(int ClienteId, int Pagina)
    : IQuery<PagedResult<PedidoResumoDto>>;

public class ListarPedidosHandler(IReadDbContext db)
    : IQueryHandler<ListarPedidosQuery, PagedResult<PedidoResumoDto>>
{
    public async Task<PagedResult<PedidoResumoDto>> HandleAsync(ListarPedidosQuery q)
        => await db.PedidosView  // view desnormalizada, otimizada para leitura
            .Where(p => p.ClienteId == q.ClienteId)
            .OrderByDescending(p => p.DataCriacao)
            .ToPagedResultAsync(q.Pagina);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

// ❌ Lock-in direto ao Azure:
public class PedidoService
{
    private readonly BlobServiceClient _blob;   // Azure SDK direto
    private readonly ServiceBusClient _bus;     // Azure SDK direto

    public async Task ProcessarAsync(Pedido p)
    {
        await _blob.GetBlobContainerClient("pedidos")
            .UploadBlobAsync(p.Id.ToString(), /* ... */);
        await _bus.CreateSender("pedidos").SendMessageAsync(/* ... */);
    }
}

// ✅ Com abstração (Adapter + Facade):
public class PedidoService(IArmazenamento storage, IFilaMensagens fila)
{
    public async Task ProcessarAsync(Pedido p)
    {
        await storage.SalvarAsync("pedidos", p.Id.ToString(), p);
        await fila.PublicarAsync("pedidos", new PedidoCriadoEvent(p.Id));
    }
}

// Implementações podem ser swapped sem tocar no serviço:
// services.AddSingleton<IArmazenamento, AzureBlobStorage>();
// services.AddSingleton<IArmazenamento, S3Storage>();
// services.AddSingleton<IArmazenamento, LocalFileSystem>(); // dev/test

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

Fase 1 — Construção (6-18 meses):
  Time original: sêniors motivados, conhecimento profundo do domínio
  Foco: velocidade de entrega, features, go-to-market
  Risco: decisões rápidas sem documentar trade-offs

Fase 2 — Crescimento (1-3 anos):
  Time: mistura originais + novos membros
  Foco: escalar times, manter velocidade
  Risco: divergência de padrões, "ilhas de conhecimento"

Fase 3 — Maturidade (3-10 anos):
  Time: principalmente sustentação, poucos originais
  Foco: estabilidade, correções, pequenas evoluções
  Risco: "ningúem sabe por que esse código existe"

Fase 4 — Legado (10+ anos):
  Time: sustentação, possível offshore
  Foco: manter funcionando sem quebrar
  Risco: reescrita forçada por acumulação de débito técnico

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

# ADR-007: Uso do padrão Strategy para cálculo de frete

**Status:** Aceito  
**Data:** 2025-03-15  
**Contexto:** O cálculo de frete precisa suportar múltiplas transportadoras,
com possibilidade de adicionar novas sem alterar o código existente.

**Decisão:** Implementar usando o padrão Strategy com injeção de dependência.
A seleção da estratégia será feita na composition root baseada na configuração.

**Consequências:**
- ✅ Adicionar nova transportadora = criar nova classe, sem alterar código existente
- ✅ Cada estratégia é testável de forma isolada
- ✅ A regra de seleção fica explícita e centralizada
- ⚠️ Mais classes no projeto (aceitável, cada uma tem responsabilidade clara)
- ❌ Não usar: quando há apenas uma forma de calcular e não há perspectiva de mudança

**Padrões relacionados:** Factory Method (para criar a Strategy correta), Open/Closed Principle

1
2
3
4
5
6
7

// ❌ Viola Demeter — "train wreck code"
// O serviço conhece a estrutura interna de 4 objetos diferentes:
var cidade = pedido.Cliente.Endereco.Cidade.Nome;

// ✅ Respeita Demeter — adicionar método no objeto responsável:
var cidade = pedido.ObterCidadeEntrega();
// "Pegue apenas uma etapa por vez"

1
2
3
4
5
6
7

// ❌ Factory para uma única implementação que não vai mudar:
public interface ICalculadorImposto { decimal Calcular(decimal valor); }
public class CalculadorImpostoFactory { public ICalculadorImposto Criar() => new CalculadorImposto(); }
public class CalculadorImposto : ICalculadorImposto { public decimal Calcular(decimal v) => v * 0.12m; }

// ✅ Quando há apenas uma implementação e nenhuma previsão de mudança:
public static decimal CalcularImposto(decimal valor) => valor * 0.12m;

1
2
3
4
5
6
7
8
9

// ❌ Singleton como acesso global (dificulta testes, oculta dependências):
var db = DatabaseSingleton.Instancia;       // acoplamento global
var cache = CacheSingleton.Instancia;       // impossível testar isoladamente
var config = ConfigSingleton.Instancia;     // mudanças afetam todo o app silenciosamente

// ✅ Singleton gerenciado pelo contêiner de DI (testável, substituível):
services.AddSingleton<IDatabaseContext, DatabaseContext>();
services.AddSingleton<ICache, RedisCache>();
// Nos testes: AddSingleton<ICache, InMemoryCache>()