C# Academy · Aula

Interfaces genéricas

Abstraia sobre tipos.

Interfaces genéricas é uma aula grátis de C# Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de C# Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de C# Academy inclui 4 aulas no total.

O que é uma interface genérica?

Uma interface genérica declara parâmetros de tipo entre colchetes angulares após seu nome. As classes que a implementam escolhem os tipos concretos, e o contrato da interface se adapta de acordo.

A biblioteca do .NET as utiliza em toda parte, por exemplo, IEnumerable<T> e IComparable<T>.

interface IRepository<T>
{
    void Add(T item);
    T Get(int id);
}

Implementando uma interface genérica

Uma classe pode implementar uma interface genérica fornecendo um argumento de tipo concreto. As assinaturas dos métodos passam então a usar esse tipo real.

Isso produz um contrato seguro quanto aos tipos e reutilizável, sem conversões.

using System.Collections.Generic;

class IntStore : IRepository<int>
{
    private readonly List<int> data = new();
    public void Add(int item) => data.Add(item);
    public int Get(int id) => data[id];
}

interface IRepository<T>
{
    void Add(T item);
    T Get(int id);
}

Mantendo a classe que implementa genérica

Uma classe pode implementar uma interface genérica e continuar sendo genérica, encaminhando seu próprio parâmetro de tipo para a interface.

Isso mantém a implementação reutilizável para qualquer tipo de elemento.

using System.Collections.Generic;

class Store<T> : IRepository<T>
{
    private readonly List<T> data = new();
    public void Add(T item) => data.Add(item);
    public T Get(int id) => data[id];
}

interface IRepository<T> { void Add(T item); T Get(int id); }

IComparable<T> em ação

IComparable<T> é uma interface genérica integrada. Implementá-la permite que seu tipo defina como as instâncias são ordenadas, possibilitando a classificação.

O método CompareTo retorna um valor negativo, zero ou positivo.

class Money : IComparable<Money>
{
    public int Cents;
    public int CompareTo(Money? other)
        => Cents.CompareTo(other?.Cents ?? 0);
}

Implementando IEnumerable<T>

IEnumerable<T> é o núcleo de LINQ e foreach. Um tipo que o implementa pode ser percorrido. Muitas vezes, você delega ao iterador de uma coleção interna.

Métodos iteradores com yield return tornam isso fácil.

using System.Collections;
using System.Collections.Generic;

class Bag<T> : IEnumerable<T>
{
    private readonly List<T> items = new();
    public void Add(T x) => items.Add(x);
    public IEnumerator<T> GetEnumerator() => items.GetEnumerator();
    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
}

Uma interface genérica funcional

Este programa completo define uma IPrinter<T> genérica, implementa-a para cadeias de caracteres e depois a utiliza.

A interface garante um método Print, qualquer que seja o tipo concreto.

using System;

interface IPrinter<T> { void Print(T value); }

class ConsolePrinter<T> : IPrinter<T>
{
    public void Print(T value) => Console.WriteLine(value);
}

class Program
{
    static void Main()
    {
        IPrinter<string> p = new ConsolePrinter<string>();
        p.Print("hello generics");
    }
}

Covariância com out

Um parâmetro de uma interface genérica marcado com out é covariante: ele aparece apenas em posições de saída. Isso permite usar IEnumerable<Cat> onde se espera IEnumerable<Animal>.

A covariância preserva a compatibilidade de atribuição ao longo de uma cadeia de herança.

interface IProducer<out T>
{
    T Produce();
}

Contravariância com in

Um parâmetro marcado com in é contravariante: ele aparece apenas em posições de entrada. Isso permite usar um IComparer<Animal> onde é necessário um IComparer<Cat>.

A contravariância inverte a direção da atribuição compatível para consumidores.

interface IConsumer<in T>
{
    void Consume(T item);
}

Vários parâmetros de tipo

As interfaces genéricas podem receber mais de um parâmetro. IDictionary<TKey, TValue> é um exemplo conhecido, com tipos separados para chave e valor.

Cada parâmetro pode ser invariável, covariante ou contravariante de forma independente.

interface IMapper<TIn, TOut>
{
    TOut Map(TIn input);
}

Programar para a interface

Depender de uma interface genérica, em vez de uma classe concreta, torna o código flexível. Pode trocar as implementações sem alterar o código chamador.

Parâmetros de métodos tipados como IEnumerable<T> aceitam listas, vetores e resultados de consultas da mesma forma.

using System.Collections.Generic;
using System.Linq;

int Total(IEnumerable<int> values) => values.Sum();

Restrições com interfaces genéricas

As interfaces genéricas aparecem frequentemente como restrições. where T : IComparable<T> permite que um método ordene ou compare suas entradas.

Isso combina dois recursos de genéricos para criar algoritmos seguros e reutilizáveis.

T Min<T>(T a, T b) where T : IComparable<T>
    => a.CompareTo(b) <= 0 ? a : b;

Verificação rápida

Teste sua compreensão sobre interfaces genéricas.

Recapitulação

As interfaces genéricas declaram parâmetros de tipo e permitem que as implementações os fixem ou encaminhem. Entre os exemplos incorporados estão IEnumerable<T>, IComparable<T> e IDictionary<TKey, TValue>.

As anotações de variância out e in permitem covariância e contravariância, e as interfaces genéricas combinam naturalmente com as restrições where.

Perguntas Frequentes

A aula “Interfaces genéricas” é grátis?

Sim — o texto completo de “Interfaces genéricas” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de C# Academy, atualize para CoddyKit PRO. O curso de C# Academy inclui 4 aulas no total.

O que vou aprender em “Interfaces genéricas”?

Abstraia sobre tipos. Você pratica C# Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar C# Academy?

Nenhuma experiência prévia é necessária. C# Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Interfaces genéricas”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de C# Academy?

Sim. Cada aula de C# Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para C# Academy