Los genéricos te permiten escribir clases y métodos parametrizados por un tipo, proporcionando seguridad de tipos y reutilización sin duplicación de código ni conversiones. Las restricciones limitan qué tipos puede ser un parámetro genérico, permitiendo el uso seguro de sus miembros. Los genéricos están omnipresentes en C# (toda la biblioteca de colecciones los utiliza).
=> arr[i];
=> arr[i];
x = Get([] { , , }, );
Los genéricos trasladan los errores de tipo de tiempo de ejecución (conversión de object) a tiempo de compilación, y eliminan las conversiones — código seguro y reutilizable.
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
Las restricciones (where T : ...) limitan qué puede ser T, lo que te permite usar de manera segura los miembros de ese tipo (p. ej., restringiendo a IComparable<T> te permite llamar a CompareTo). Sin una restricción, T podría ser cualquier cosa, por lo que no puedes asumir ningún miembro.
List<T>, Dictionary<K,V>, IEnumerable<T>, Task<T>, Nullable<T> ...
→ the entire collections library and much of .NET is generic.
Los genéricos son fundamentales para C# — se utilizan de manera generalizada (toda la biblioteca de colecciones, Task<T>, IEnumerable<T> y innumerables APIs son genéricas), por lo que comprenderlos es esencial para cualquier desarrollo en C#.
Los genéricos resuelven un problema real: escribir código reutilizable que funcione para múltiples tipos mientras se preserva la seguridad de tipos — la alternativa (usar object y conversiones) sacrifica la seguridad en tiempo de compilación y requiere conversiones propensas a errores, mientras que duplicar código por tipo es inmantenible.
Los genéricos te proporcionan código reutilizable y seguro en cuanto a tipos sin conversiones ni verificación de errores en tiempo de compilación. Las restricciones (where T : ...) son un complemento importante: limitan qué puede ser un parámetro de tipo, lo que tanto permite el uso seguro de los miembros del tipo (restringir a una interfaz te permite llamar a sus métodos) como asegura el uso correcto.
Comprender las clases y métodos genéricos, cómo funciona la inferencia de tipos y las restricciones (class, struct, new(), restricciones de interfaz/clase base) es necesario tanto para usar las bibliotecas .NET que usan genéricos de manera efectiva como para escribir tus propias abstracciones reutilizables y seguras en cuanto a tipos.
Ya que los genéricos sustentan las colecciones de C# y gran parte del framework, y ya que son la clave para código reutilizable y seguro en cuanto a tipos, dominar los genéricos y las restricciones es conocimiento esencial y de aplicación frecuente para el desarrollo efectivo en C# y un tema común que refleja la comprensión del diseño reutilizable y seguro en cuanto a tipos.