C# Generics - W3spoint

C# Generics are a powerful feature of the C# programming language that allow you to define classes, interfaces, and methods that can work with different data types without sacrificing type safety. Generics provide a way to create reusable code that is more flexible and efficient.

Here’s a brief overview of how generics work in C#:

Generic Classes: You can define a generic class by specifying one or more type parameters in angle brackets (<>) after the class name. These type parameters represent a placeholder for the actual data type that will be used when an instance of the class is created. For example:

public class MyGenericClass<T>
{
    // You can use the type parameter 'T' within the class
    private T myField;

    public MyGenericClass(T initialValue)
    {
        myField = initialValue;
    }

    public T GetMyField()
    {
        return myField;
    }
}

Generic Methods: Similar to generic classes, you can also define generic methods that can work with different types. The type parameters are specified before the return type of the method. For example:

public class MyGenericClass
{
    public void MyGenericMethod<T>(T argument)
    {
        // Do something with the argument of type 'T'
    }
}

Constraints: You can apply constraints to the type parameters in generics to restrict the types that can be used. Common constraints include specifying that the type must be a class (where T : class), a struct (where T : struct), have a default constructor (where T : new()), or implement a specific interface (where T : IInterface). Constraints help ensure that the code will work with the expected types.

public class MyGenericClass<T> where T : IComparable
{
    // ...
}

Generic Interfaces: You can also define generic interfaces that specify type parameters for the methods or properties declared in the interface. These type parameters are then implemented by the classes that implement the interface.

public interface IMyGenericInterface<T>
{
    void MyMethod(T argument);
}

Generics provide many benefits, including code reuse, improved type safety, and performance optimizations. They enable you to write more generic and flexible code that can work with a wide range of data types while maintaining compile-time type checking.