Generics in C# Explained

Generics in C# allow you to create classes, methods, and interfaces that can work with any data type. This provides flexibility and type safety, reducing the need for typecasting and improving code reusability. Let's explore the key concepts related to Generics in C#.

1. Generic Classes

A generic class is a class that can work with any data type. The type of the data is specified when the class is instantiated. This allows you to create a single class that can handle different types of data without duplicating code.

Example

class GenericList<T>
{
    private T[] items;
    private int count;

    public GenericList(int capacity)
    {
        items = new T[capacity];
        count = 0;
    }

    public void Add(T item)
    {
        if (count < items.Length)
        {
            items[count] = item;
            count++;
        }
    }

    public T GetItem(int index)
    {
        if (index < count)
        {
            return items[index];
        }
        else
        {
            throw new IndexOutOfRangeException("Index out of range");
        }
    }
}

class Program
{
    static void Main(string[] args)
    {
        GenericList<int> intList = new GenericList<int>(5);
        intList.Add(1);
        intList.Add(2);
        Console.WriteLine(intList.GetItem(0)); // Output: 1

        GenericList<string> stringList = new GenericList<string>(5);
        stringList.Add("Hello");
        stringList.Add("World");
        Console.WriteLine(stringList.GetItem(1)); // Output: World
    }
}

In this example, the GenericList<T> class can work with any data type. When creating an instance of GenericList, you specify the type of data it will handle, such as int or string.

2. Generic Methods

Generic methods are methods that can work with any data type. The type of the data is specified when the method is called. This allows you to create a single method that can handle different types of data without duplicating code.

Example

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

class Program
{
    static void Main(string[] args)
    {
        int x = 5, y = 10;
        GenericMethodExample.Swap<int>(ref x, ref y);
        Console.WriteLine($"x: {x}, y: {y}"); // Output: x: 10, y: 5

        string s1 = "Hello", s2 = "World";
        GenericMethodExample.Swap<string>(ref s1, ref s2);
        Console.WriteLine($"s1: {s1}, s2: {s2}"); // Output: s1: World, s2: Hello
    }
}

In this example, the Swap<T> method can swap the values of any two variables of the same type. When calling the method, you specify the type of data it will handle, such as int or string.

3. Generic Interfaces

A generic interface is an interface that can work with any data type. The type of the data is specified when the interface is implemented. This allows you to create a single interface that can handle different types of data without duplicating code.

Example

interface IRepository<T>
{
    void Add(T item);
    T Get(int id);
}

class ProductRepository : IRepository<Product>
{
    private List<Product> products;

    public ProductRepository()
    {
        products = new List<Product>();
    }

    public void Add(Product item)
    {
        products.Add(item);
    }

    public Product Get(int id)
    {
        return products.FirstOrDefault(p => p.Id == id);
    }
}

class Product
{
    public int Id { get; set; }
    public string Name { get; set; }
}

class Program
{
    static void Main(string[] args)
    {
        ProductRepository repo = new ProductRepository();
        repo.Add(new Product { Id = 1, Name = "Laptop" });
        Product product = repo.Get(1);
        Console.WriteLine(product.Name); // Output: Laptop
    }
}

In this example, the IRepository<T> interface can work with any data type. The ProductRepository class implements this interface for the Product type, allowing it to handle Product objects.

4. Constraints in Generics

Constraints in generics allow you to restrict the types that can be used with a generic class, method, or interface. This ensures that only certain types of data can be used, providing additional type safety and enabling the use of specific methods and properties of the constrained types.

Example

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

class Program
{
    static void Main(string[] args)
    {
        GenericClassWithConstraint<int> intClass = new GenericClassWithConstraint<int>();
        Console.WriteLine(intClass.Max(5, 10)); // Output: 10

        GenericClassWithConstraint<string> stringClass = new GenericClassWithConstraint<string>();
        Console.WriteLine(stringClass.Max("Apple", "Banana")); // Output: Banana
    }
}

In this example, the GenericClassWithConstraint<T> class is constrained to types that implement the IComparable<T> interface. This allows the Max method to use the CompareTo method, which is defined in the IComparable<T> interface.

Conclusion

Generics in C# provide a powerful mechanism for creating flexible, reusable, and type-safe code. By understanding and applying generic classes, methods, interfaces, and constraints, you can write more efficient and maintainable code. Generics allow you to work with any data type, reducing the need for typecasting and improving code reusability.