Generics in C# Language

C# is a versatile and widely used programming language, known for its robustness and flexibility. One of its

key features, generics, empowers developers to write reusable and type-safe code. In this post, we will delve into the world of generics in C#, understand their significance, and explore practical examples of how they can enhance your coding experience.

What are Generics?

Generics in C# provide a mechanism for creating classes, structures, interfaces, methods, and delegates that work with different data types. They allow you to write code that can be used with various data types, while still maintaining type safety.

Generics serve two primary purposes:

1. Code Reusability: Generics enable you to write functions and classes that can be used with a wide range of data types. This promotes code reuse, reducing the need to duplicate code for similar operations on different data types.
2. Type Safety: With generics, the C# compiler ensures that the data types used with generic types are compatible at compile-time, reducing the risk of runtime errors.

Practical Examples of Generics

• Generic Classes

public class GenericList<T>
{
    private List<T> _items = new List<T>();

    public void Add(T item)
    {
        _items.Add(item);
    }

    public T GetItem(int index)
    {
        return _items[index];
    }
}

In the example above, we’ve defined a generic class called GenericList. This class can work with any data type. You can create instances of this class with various types, ensuring both code reusability and type safety.

• Generic Methods

public T FindMax<T>(T[] array) where T : IComparable<T>
{
    if (array.Length == 0)
        throw new InvalidOperationException("The array is empty.");

    T max = array[0];
    foreach (T item in array)
    {
        if (item.CompareTo(max) > 0)
        {
            max = item;
        }
    }
    return max;
}

The FindMax method is a generic method that can find the maximum value in an array of any type that implements the IComparable interface. This demonstrates the power of generics in making code more versatile without sacrificing type safety.

• Generic Interfaces

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

With generic interfaces, you can create repositories for different types of entities in a database, ensuring a consistent pattern for data access.