Da trilha de C# Este conceito ainda não saiu como card do dia. ir para o card de hoje

C# POO Intermediário

Interfaces

Em C#, uma interface define um contrato que as classes podem implementar. Ela especifica quais membros (métodos, propriedades, eventos) uma classe deve fornecer, mas não como. Isso permite que objetos de tipos diferentes sejam tratados de forma uniforme, promovendo polimorfismo e baixo acoplamento.

A partir do C# 8, interfaces podem ter métodos default (com implementação padrão), o que permite evoluir a interface sem quebrar as classes existentes. Classes podem implementar múltiplas interfaces, superando a limitação da herança única de classes. Além disso, interfaces podem ser genéricas, oferecendo contratos fortemente tipados e reutilizáveis.

Neste card, você verá como declarar e implementar interfaces, usar múltiplas interfaces, aproveitar métodos default e criar interfaces genéricas. Esses recursos são fundamentais para escrever código flexível e testável.

Pontos-chave

  • Uma interface define um contrato que as classes devem seguir, sem fornecer implementação (exceto métodos default).
  • Uma classe pode implementar várias interfaces, permitindo composição de comportamentos.
  • Métodos default em interfaces fornecem uma implementação padrão, evitando quebra de código existente.
  • Interfaces genéricas permitem contratos reutilizáveis e seguros em termos de tipo.
  • Use interfaces para desacoplar código e facilitar testes e injeção de dependência.
InterfacesDemo.cs
using System;

// Interface simples
public interface IAnimal
{
    void EmitirSom();
}

// Interface com método default (C# 8+)
public interface ICorredor
{
    void Correr() => Console.WriteLine("Correndo...");
}

// Interface genérica
public interface IRepositorio<T>
{
    void Adicionar(T item);
    T Obter(int id);
}

// Classe implementa múltiplas interfaces
public class Cachorro : IAnimal, ICorredor
{
    public void EmitirSom() => Console.WriteLine("Latido");
    // Correr() não precisa ser implementado, usa o default
}

// Implementação da interface genérica
public class RepositorioMemoria<T> : IRepositorio<T>
{
    private readonly System.Collections.Generic.List<T> _itens = new();
    public void Adicionar(T item) => _itens.Add(item);
    public T Obter(int id) => _itens[id];
}

public class Program
{
    public static void Main()
    {
        IAnimal animal = new Cachorro();
        animal.EmitirSom(); // Latido

        ICorredor corredor = new Cachorro();
        corredor.Correr(); // Correndo... (método default)

        var repo = new RepositorioMemoria<string>();
        repo.Adicionar("Item 1");
        Console.WriteLine(repo.Obter(0)); // Item 1
    }
}

Exercícios

  1. 1
    Fácil

    Implementando uma interface simples

    Crie uma interface IVeiculo com o método Mover(). Depois, crie a classe Carro que implementa IVeiculo e imprime "Carro em movimento". No Main, instancie um Carro e chame Mover().

    Resolver
  2. 2
    Médio

    Múltiplas interfaces e método default

    Crie duas interfaces: IAndar com o método Andar() e INadar com o método Nadar(). A interface INadar deve ter um método default que imprime "Nadando...". Crie a classe Pato que implementa ambas as interfaces. No Main, crie um Pato, chame Andar() (implementado na classe) e Nadar() (método default).

    Resolver
  3. 3
    Desafio

    Interface genérica e restrições

    Crie uma interface genérica IRepositorio<T> com os métodos Adicionar(T item) e T Obter(int indice). Implemente a classe RepositorioMemoria<T> que armazena os itens em uma lista interna. No Main, crie um repositório de string, adicione "C#" e "Interfaces", e exiba o item de índice 1. Em seguida, crie um repositório de int, adicione 10 e 20, e exiba o item de índice 0.

    Resolver

Continue estudando