Type Parameters

Type parameters, also known as generic type parameters or simply generics, are a feature in C# that allows you to define classes, interfaces, methods, and delegates without specifying the exact data types they work with. Instead, you provide placeholders for the data types, which can be replaced with specific types when you instantiate or use the generic class, interface, method, or delegate. This enables you to create reusable, type-safe, and efficient code without having to write multiple versions for each data type.

Generics in C# help you avoid code duplication, improve type safety, and increase performance by allowing the compiler to perform type-specific optimizations. They are particularly useful when working with collections, as they provide a way to enforce type constraints and eliminate the need for type casting.

Here's an example of a simple generic class in C#:

public class GenericBox<T>
{
    private T _item;

    public void SetItem(T item)
    {
        _item = item;
    }

    public T GetItem()
    {
        return _item;
    }
}

In this example, T is the type parameter, which is a placeholder for the actual data type that the GenericBox class will work with. When you create an instance of the GenericBox class, you can specify the data type to be used:

var intBox = new GenericBox<int>();
intBox.SetItem(42);
int item = intBox.GetItem();

var stringBox = new GenericBox<string>();
stringBox.SetItem("Hello, world!");
string message = stringBox.GetItem();

You can also define generic methods within non-generic classes, as shown below:

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

// Usage:
int x = 10;
int y = 20;
Utility.Swap<int>(ref x, ref y);

string str1 = "hello";
string str2 = "world";
Utility.Swap<string>(ref str1, ref str2);

In this example, the Swap method has a type parameter T, allowing it to swap values of any data type without having to write separate methods for each type.

Type parameters in C# enable you to create reusable, type-safe, and efficient code by defining generic classes, interfaces, methods, and delegates that work with a variety of data types.

02 February 2024