Genéricos permitem escrever classes e métodos parametrizados por um tipo, fornecendo segurança de tipo e reutilizabilidade sem duplicação de código ou casts. Restrições restringem quais tipos um parâmetro genérico pode ser, permitindo o uso seguro de seus membros. Genéricos são generalizados em C# (a biblioteca inteira de coleções os utiliza).
=> arr[i];
=> arr[i];
x = Get([] { , , }, );
Genéricos movem erros de tipo do tempo de execução (cast de object) para o tempo de compilação e eliminam casts — código seguro e reutilizável.
public class Box<T> // a generic class
{
private T _value;
public void Set(T value) => _value = value;
public T Get() => _value;
}
var box = new Box<string>(); // T = string, type-safe
// generic method
public T Max<T>(T a, T b) where T : IComparable<T> // constraint (see below)
=> a.CompareTo(b) > 0 ? a : b;
where T : class // T must be a reference type
where T : struct // T must be a value type
where T : new() // T must have a parameterless constructor
where T : IComparable<T> // T must implement an interface (so you can call its members)
where T : BaseClass // T must derive from BaseClass
// example: constraint lets you call CompareTo safely
public T Max<T>(T a, T b) where T : IComparable<T>
=> a.CompareTo(b) > 0 ? a : b; // CompareTo is available because of the constraint
Restrições (where T : ...) restringem o que T pode ser, o que permite usar com segurança os membros desse tipo (ex: restringir a IComparable<T> permite chamar CompareTo). Sem uma restrição, T poderia ser qualquer coisa, então você não pode assumir nenhum membro.
List<T>, Dictionary<K,V>, IEnumerable<T>, Task<T>, Nullable<T> ...
→ the entire collections library and much of .NET is generic.
Genéricos são fundamentais para C# — eles são usados amplamente (a biblioteca inteira de coleções, Task<T>, IEnumerable<T> e inúmeras APIs são genéricas), então entendê-los é essencial para qualquer desenvolvimento em C#.
Genéricos resolvem um problema real: escrever código reutilizável que funcione para múltiplos tipos preservando segurança de tipo — a alternativa (usar object e casting) sacrifica segurança em tempo de compilação e requer casts propensos a erros, enquanto duplicar código por tipo é difícil de manter.
Genéricos lhe dão código reutilizável e type-safe sem casting e com verificação de erro em tempo de compilação. Restrições (where T : ...) são um complemento importante: elas restringem o que um parâmetro de tipo pode ser, o que tanto permite o uso seguro dos membros do tipo (restringir a uma interface permite chamar seus métodos) quanto garante o uso correto.
Entender classes e métodos genéricos, como a inferência de tipo funciona, e restrições (class, struct, new(), restrições de interface/classe base) é necessário tanto para usar as bibliotecas .NET generalizadas com eficácia quanto para escrever suas próprias abstrações reutilizáveis e type-safe.
Como genéricos fundamentam as coleções de C# e grande parte do framework, e como são a chave para código reutilizável e type-safe, dominar genéricos e restrições é conhecimento fundamental e frequentemente aplicado para desenvolvimento eficaz em C# e um tópico comum refletindo compreensão de design reutilizável e type-safe.