Generics en C#: para qué sirven y cómo usarlos

Introducción a los Generics en C#

Los Generics (tipos genéricos) son una de las características más potentes del lenguaje C#, introducida en .NET Framework 2.0. Permiten crear clases, métodos e interfaces que funcionan con cualquier tipo de datos, manteniendo al mismo tiempo una tipificación estricta. En este artículo analizaremos para qué sirven los generics en C#, cómo usarlos y qué ventajas ofrecen al desarrollador.

Imagina que necesitas escribir un método para intercambiar los valores de dos variables. Sin generics, tendrías que crear métodos separados para cada tipo: SwapInt, SwapString, SwapDouble y así sucesivamente. Con generics, este problema se resuelve con una única función universal.

Principales ventajas de los Generics

1. Seguridad de tipos en tiempo de compilación

Los Generics garantizan la verificación de tipos durante la compilación, no durante la ejecución. Esto significa que los errores relacionados con la incompatibilidad de tipos se detectarán en una etapa temprana del desarrollo.

// Sin generics - posible error en tiempo de ejecuciónArrayList list = new ArrayList();list.Add(123);list.Add("cadena");int number = (int)list[1]; // InvalidCastException!

// Con generics - error en tiempo de compilaciónList<int> numbers = new List<int>();numbers.Add(123);numbers.Add("cadena"); // Error de compilación!

2. Rendimiento

El uso de generics permite evitar las operaciones de boxing y unboxing para tipos de valor. Esto mejora significativamente el rendimiento al trabajar con colecciones.

// Boxing/Unboxing - lentoArrayList list = new ArrayList();list.Add(42); // boxingint value = (int)list[0]; // unboxing

// Generics - rápido, sin boxingList<int> list = new List<int>();list.Add(42); // sin boxingint value = list[0]; // sin unboxing

3. Reutilización de código

Una clase o método genérico puede funcionar con cualquier tipo de datos, lo que elimina la duplicación de código.

Creación y uso de Generics

Clases genéricas

Veamos un ejemplo de creación de una clase genérica para almacenar un par de valores:

public class Pair<TFirst, TSecond>{    public TFirst First { get; set; }    public TSecond Second { get; set; }        public Pair(TFirst first, TSecond second)    {        First = first;        Second = second;    }        public void Display()    {        Console.WriteLine($"First: {First}, Second: {Second}");    }}

// Usovar pair1 = new Pair<int, string>(1, "uno");var pair2 = new Pair<string, double>("PI", 3.14159);

pair1.Display(); // First: 1, Second: unopair2.Display(); // First: PI, Second: 3.14159

Métodos genéricos

Los métodos también pueden ser genéricos. Aquí tienes un ejemplo clásico: el método de intercambio de valores:

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

// Usoint x = 5, y = 10;Swap<int>(ref x, ref y);Console.WriteLine($"x = {x}, y = {y}"); // x = 10, y = 5

string s1 = "Hello", s2 = "World";Swap(ref s1, ref s2); // el tipo se puede omitirConsole.WriteLine($"s1 = {s1}, s2 = {s2}"); // s1 = World, s2 = Hello

Interfaces genéricas

Las interfaces con generics permiten crear contratos flexibles:

public interface IRepository<T>{    T GetById(int id);    void Add(T entity);    void Update(T entity);    void Delete(int id);}

public class UserRepository : IRepository<User>{    public User GetById(int id)    {        // Implementación de obtención de usuario        return new User();    }        public void Add(User user)    {        // Implementación de agregado    }        public void Update(User user)    {        // Implementación de actualización    }