Interfaces e Classes Abstratas - Quando Usar

Interfaces vs.
Classes Abstratas em C#

1. Fundamentos da Abstração

Para construir sistemas escaláveis, precisamos definir regras sem necessariamente ditar como elas serão executadas. Veja as duas principais ferramentas do C#.

Classe Abstrata

public abstract class Veiculo 
{
    // Código compartilhado
    public void LigarMotor() { ... }

    // Contrato obrigatório
    public abstract void Mover();
}

2. Quando usar qual?

O grande dilema do arquiteto de software resolvido com critérios técnicos. Analise o radar de capacidades abaixo para tomar a decisão correta.

* Capacidades comparativas no design de arquitetura C#

3. Laboratório Prático

Implementação de um sistema de notificações (E-mail e SMS) usando os conceitos arquiteturais. O componente principal não sabe qual serviço está usando, apenas confia no contrato da Interface.

O Contrato (Interface)

interface INotificacaoService 
{
  void Enviar(string msg);
}

As Implementações

class EmailService : INotificacaoService📧

class SmsService : INotificacaoService📱

💻Painel de Desacoplamento

1. Injetar Dependência (Escolha o Serviço):

2. Dados da Notificação:

Console Output

// Aguardando injeção do serviço...

4. Resultado do Laboratório Prático

Abaixo, o código real consolidado. Observe como a classe Notificador não conhece os detalhes de envio, apenas a interface.

// 1. O Contrato
public interface IMensageiro { void Enviar(string msg); }

// 2. Implementações concretas
public class EmailService : IMensageiro 
{
    public void Enviar(string msg) => Console.WriteLine($"[E-MAIL] HTML Formatado: {msg}");
}

public class SmsService : IMensageiro 
{
    public void Enviar(string msg) => Console.WriteLine($"[SMS] Enviando torpedo: {msg}");
}

// 3. A mágica da Injeção de Dependência
public class Notificador 
{
    private readonly IMensageiro _mensageiro;
    public Notificador(IMensageiro m) => _mensageiro = m;
    
    public void Notificar(string msg) => _mensageiro.Enviar(msg);
}