C# - Violações dos princípios SOLID

Na linha de código em destque o código tenta realizar uma conversão explícita de checkout para PagamentoCartao, o que só é possível se checkout for de fato uma instância de PagamentoCartao ou de uma classe derivada. Se a estratégia de pagamento atual for outra classe que não é derivada de PagamentoCartao, essa conversão vai falhar em tempo de execução.

Por isso, para evitar esse tipo de problema, é importante utilizar sempre a interface comum para acessar a estratégia de pagamento, como fizemos no exemplo corrigido. Assim, podemos trocar a implementação da estratégia sem precisar alterar o código do cliente que utiliza essa estratégia.

Para resolver esse problema, podemos adicionar o método PagarEmParcelas() na interface IPagamento, de forma que todas as estratégias de pagamento devem implementá-lo. Dessa forma, podemos remover a violação do princípio LSP e utilizar as diferentes estratégias de pagamento sem precisar fazer a conversão explícita.

O código modificado ficaria assim:

Checkout checkout = new Checkout(new PagamentoDinheiro());
checkout.FinalizarCompra(100.0);

checkout = new Checkout(new PagamentoCartao());
checkout.FinalizarCompra(100.0);

checkout.FinalizarCompraParcelado(100.0, 3);

checkout = new Checkout(new PagamentoBoleto());
checkout.FinalizarCompra(100.0);

Console.ReadLine();

interface IPagamento
{
void Pagar(double valor);
void PagarEmParcelas(double valor, int parcelas);
}

class PagamentoDinheiro : IPagamento
{
    public void Pagar(double valor)
    {
        Console.WriteLine($"Pagamento em dinheiro de {valor:C}");
    }

    public void PagarEmParcelas(double valor, int parcelas)
    {
        Console.WriteLine("Não é possível parcelar pagamentos em dinheiro.");
    }
}

class PagamentoCartao : IPagamento
{
    public void Pagar(double valor)
    {
        Console.WriteLine($"Pagamento com cartão de {valor:C}");
    }

    public void PagarEmParcelas(double valor, int parcelas)
    {
        Console.WriteLine($"Pagamento em {parcelas} parcelas de {(valor / parcelas):C}");
    }
}

class PagamentoBoleto : IPagamento
{
    public void Pagar(double valor)
    {
        Console.WriteLine($"Pagamento com boleto de {valor:C}");
    }

    public void PagarEmParcelas(double valor, int parcelas)
    {
        Console.WriteLine("Não é possível parcelar pagamentos com boleto.");
    }
}

class Checkout
{
private IPagamento _pagamento;

    public Checkout(IPagamento pagamento)
    {
        _pagamento = pagamento;
    }

    public void FinalizarCompra(double valor)
    {
        _pagamento.Pagar(valor);
    }

    public void FinalizarCompraParcelado(double valor, int parcelas)
    {
        _pagamento.PagarEmParcelas(valor, parcelas);
    }
}

Agora adicionamos o método PagarEmParcelas() na interface IPagamento e o implementamos em todas as estratégias de pagamento. Dessa forma, podemos chamar o método FinalizarCompraParcelado() na classe Checkout, que chama o método PagarEmParcelas() na estratégia de pagamento atual. Isso garante que todas as estratégias de pagamento implementam o mesmo comportamento, evitando a violação do princípio LSP.

Além disso, observe que na classe Checkout, utilizamos diretamente a referência para um objeto que implementa a interface IPagamento, em vez de fazer a conversão explícita para uma classe específica. Isso torna o código mais genérico e flexível, permitindo a troca de estratégias de pagamento de forma mais fácil e sem precisar alterar a classe Checkout.

Com essas modificações, o código agora está em conformidade com o princípio LSP e podemos utilizar o padrão Strategy de forma correta e segura.