Genéricos en C#

¡Bienvenido a la primera lección de "Características avanzadas de C#"! En esta lección, aprenderá sobre los genéricos, una potente característica de C# que permite crear código flexible y reutilizable. ¡Comencemos!

¿Qué son los genéricos?

Los genéricos son una característica de C# que permite definir clases, métodos y estructuras de datos con un marcador de posición para el tipo de datos que almacenan o utilizan. Los genéricos permiten garantizar la seguridad de tipos y reutilizar el código.

Ejemplo: Una lista genérica (List<T>) puede almacenar elementos de cualquier tipo y, al mismo tiempo, garantizar la seguridad de tipos.

Creación de clases genéricas

Puede definir una clase genérica mediante la sintaxis <T>, donde T representa un parámetro de tipo. Ejemplo:

Punto clave: Utilice genéricos para crear clases que funcionen con cualquier tipo de datos y mantengan la seguridad de tipos.

using System;

class GenericBox<T> {
    public T Value { get; set; }

    public void Display() {
        Console.WriteLine("Value: " + Value);
    }
}

class Program {
    static void Main() {
        GenericBox<int> intBox = new GenericBox<int> { Value = 42 };
        intBox.Display(); // Outputs: Value: 42

        GenericBox<string> stringBox = new GenericBox<string> { Value = "Hello, Generics!" };
        stringBox.Display(); // Outputs: Value: Hello, Generics!
    }
}

Creación de métodos genéricos

Puede definir un método genérico dentro de una clase. Ejemplo:

Consejo: Utilice métodos genéricos para operaciones aplicables a varios tipos de datos.

using System;

class Program {
    static void Main() {
        PrintValue(42);
        PrintValue("Generics are powerful!");
    }

    static void PrintValue<T>(T value) {
        Console.WriteLine("Value: " + value);
    }
}

Restricciones de genéricos

Las restricciones limitan los tipos que se pueden utilizar como parámetros de tipo. Ejemplo:

• where T : struct - T debe ser un tipo de valor.
• where T : class - T debe ser un tipo de referencia.
• where T : new() - T debe tener un constructor sin parámetros.

Ejemplo:

Punto clave: Las restricciones hacen que los genéricos sean más flexibles y aplicables a situaciones específicas.

using System;

class Program {
    static void Main() {
        DisplayDefault<int>();
        DisplayDefault<string>();
    }

    static void DisplayDefault<T>() where T : new() {
        T instance = new T();
        Console.WriteLine("Created instance of: " + typeof(T));
    }
}

Colecciones genéricas

C# proporciona varias colecciones genéricas integradas:

• List<T>: Almacena una colección de elementos en un array dinámico.
• Dictionary<TKey, TValue>: Almacena pares clave-valor para realizar búsquedas rápidas.
• Queue<T>: Implementa una estructura de primero en entrar, primero en salir (FIFO).

Ejemplo: Uso de una lista genérica:

using System;
using System.Collections.Generic;

class Program {
    static void Main() {
        List<string> names = new List<string> { "Alice", "Bob", "Charlie" };
        names.Add("Diana");

        foreach (string name in names) {
            Console.WriteLine(name);
        }
    }
}

Desafío de práctica

Cree una clase genérica Pair<TKey, TValue> que almacene un par clave-valor y un método genérico Swap() que intercambie la clave y el valor. Ejemplo:

using System;

class Pair<TKey, TValue> {
    public TKey Key { get; set; }
    public TValue Value { get; set; }

    public void Swap() {
        (Key, Value) = ((TKey)(object)Value, (TValue)(object)Key);
    }

    public void Display() {
        Console.WriteLine($"Key: {Key}, Value: {Value}");
    }
}

class Program {
    static void Main() {
        Pair<string, int> pair = new Pair<string, int> { Key = "Age", Value = 30 };
        pair.Display();
        pair.Swap();
        pair.Display();
    }
}

Prácticas recomendadas para usar genéricos

Estas son algunas prácticas recomendadas:

• Utilice genéricos para crear clases y métodos reutilizables y con seguridad de tipos.
• Aplique restricciones cuando se necesiten requisitos específicos para los tipos.
• Prefiera las colecciones genéricas a las no genéricas por motivos de rendimiento y seguridad.

Consejo: Utilice nombres descriptivos para los parámetros de tipo, como T para tipo o TKey y TValue para pares clave-valor.

¡Excelente trabajo!

¡Enhorabuena! Ha aprendido a utilizar genéricos para crear código reutilizable y flexible en C#. En la próxima lección, exploraremos la programación asíncrona con async y await. ¡Sigamos programando!