C# Academy · Aula

Métodos genéricos

Parâmetros de tipo nos métodos.

Métodos genéricos é uma aula grátis de C# Academy no CoddyKit. Esta é a aula 1 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 são métodos genéricos?

Um método genérico declara um ou mais parâmetros de tipo próprios, escritos entre sinais de menor e maior após o nome do método. Assim, o mesmo corpo de método funciona com vários tipos sem conversões nem duplicação.

Os parâmetros de tipo são marcadores, como T. O compilador substitui o tipo real no local da chamada, mantendo tudo fortemente tipado.

void Print<T>(T value)
{
    Console.WriteLine(value);
}

Declarando um parâmetro de tipo

A lista de parâmetros de tipo <T> fica entre o nome do método e a lista de parâmetros. Você pode usar T como tipo de parâmetro, tipo de retorno ou tipo de variável local dentro do corpo.

Por convenção, parâmetros de tipo únicos recebem o nome T; nomes descritivos como TKey também são comuns.

T Echo<T>(T input)
{
    return input;
}

Chamadas com inferência de tipos

Normalmente, não é preciso especificar explicitamente o argumento de tipo. O compilador infere T a partir dos argumentos passados.

Aqui, Echo(42) infere T = int, e Echo("hi") infere T = string. A inferência de tipos mantém as chamadas genéricas limpas e legíveis.

using System;

class Program
{
    static T Echo<T>(T input) => input;

    static void Main()
    {
        Console.WriteLine(Echo(42));
        Console.WriteLine(Echo("hi"));
    }
}

Argumentos de tipo explícitos

Quando a inferência não consegue determinar o tipo ou quando desejar ser explícito, forneça o argumento de tipo entre colchetes angulares no local da chamada.

Isso é necessário quando nenhum argumento contém o tipo, por exemplo, em um método cujo T aparece apenas no tipo de retorno.

T Create<T>() where T : new() => new T();

// call:
var list = Create<int>();

Vários parâmetros de tipo

Um método genérico pode declarar vários parâmetros de tipo separados por vírgulas. Cada um é inferido ou fornecido de forma independente.

Um exemplo clássico é uma operação de troca ou um construtor de pares que combina dois tipos distintos.

(TSecond, TFirst) Flip<TFirst, TSecond>(TFirst a, TSecond b)
{
    return (b, a);
}

Uma troca genérica

Os métodos genéricos são especialmente úteis para utilitários que não dependem do tipo concreto. Uma operação de troca reordena dois valores de qualquer tipo compatível.

A palavra-chave ref permite que o método modifique diretamente as variáveis do chamador.

using System;

class Program
{
    static void Swap<T>(ref T a, ref T b)
    {
        T temp = a;
        a = b;
        b = temp;
    }

    static void Main()
    {
        int x = 1, y = 2;
        Swap(ref x, ref y);
        Console.WriteLine($"{x} {y}");
    }
}

Restrições em parâmetros de métodos

Um método genérico pode restringir seus parâmetros de tipo com uma cláusula where. As restrições informam ao compilador quais operações são permitidas em T.

A seguir, where T : IComparable<T> permite que o corpo chame CompareTo com segurança.

T Max<T>(T a, T b) where T : IComparable<T>
{
    return a.CompareTo(b) >= 0 ? a : b;
}

Métodos genéricos em classes não genéricas

Uma classe não precisa ser genérica para conter métodos genéricos. Classes utilitárias estáticas costumam reuni-los.

Isso mantém os auxiliares de uso geral agrupados sem obrigar a classe inteira a carregar um parâmetro de tipo.

static class Util
{
    public static T First<T>(T[] items) => items[0];
}

Inferência a partir de matrizes

A inferência de tipos também funciona por meio de argumentos de matrizes e coleções. Passar um int[] infere T = int automaticamente.

Isso faz com que os algoritmos genéricos pareçam recursos integrados da linguagem.

using System;

class Program
{
    static T First<T>(T[] items) => items[0];

    static void Main()
    {
        int[] nums = { 10, 20, 30 };
        Console.WriteLine(First(nums));
    }
}

Por que não usar apenas object?

Antes dos genéricos, o código usava object e conversões de tipo. Isso elimina a segurança de tipos e converte tipos de valor em objetos, prejudicando o desempenho.

Os métodos genéricos evitam o encaixotamento de tipos de valor e detectam erros de tipo em tempo de compilação, em vez de lançá-los em tempo de execução.

// Unsafe: needs a cast and can fail at runtime
object Echo(object o) => o;
int n = (int)Echo(5);

Retornando tipos diferentes

O tipo de retorno também pode ser genérico, permitindo que um método adapte sua saída ao chamador. default(T) produz o valor zero para tipos de valor ou null para tipos por referência.

Isso é útil para alternativas seguras quando nenhum valor está disponível.

T OrDefault<T>(bool ok, T value)
{
    return ok ? value : default(T);
}

Verificação rápida

Teste sua compreensão dos métodos genéricos.

Recapitulação

Os métodos genéricos declaram seus próprios parâmetros de tipo entre colchetes angulares após o nome. Normalmente, o compilador infere o tipo a partir dos argumentos, mas você pode fornecê-lo explicitamente.

Eles preservam a segurança de tipos, evitam o encaixotamento e podem incluir restrições where. Você pode colocá-los em qualquer classe, genérica ou não.

Perguntas Frequentes

A aula “Métodos genéricos” é grátis?

Sim — o texto completo de “Métodos genéricos” é 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 “Métodos genéricos”?

Parâmetros de tipo nos métodos. 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 1 de 4.

Quanto tempo leva a aula “Métodos genéricos”?

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