What is Generic Constraint in C#: Simple Explanation and Example

A generic constraint in C# limits the types that can be used with a generic class or method. It ensures that the type argument meets certain requirements, like inheriting a class or implementing an interface, so the code can safely use specific features of that type.

How It Works

Imagine you have a toolbox that can hold any kind of tool, but you want to make sure it only holds tools that can be used to fix cars. A generic constraint in C# works like a rule that says, "Only tools that can fix cars are allowed." This means when you write a generic class or method, you can tell the computer to accept only types that meet certain conditions.

For example, you might want to say the type must be a class that can start an engine or must have a parameterless constructor. This helps the computer know what it can do with the type, so it won't try to use something that doesn't fit the rule. It’s like setting a filter to keep your code safe and clear.

Example

This example shows a generic class that only accepts types which have a parameterless constructor and inherit from the Vehicle class. This lets the class create new instances and use Vehicle features safely.

csharp

public class Vehicle
{
    public void StartEngine()
    {
        System.Console.WriteLine("Engine started.");
    }
}

public class Car : Vehicle
{
    public Car() { }
}

public class Garage<T> where T : Vehicle, new()
{
    public T CreateVehicle()
    {
        T vehicle = new T();
        vehicle.StartEngine();
        return vehicle;
    }
}

class Program
{
    static void Main()
    {
        Garage<Car> carGarage = new Garage<Car>();
        Car myCar = carGarage.CreateVehicle();
    }
}

Output

Engine started.

When to Use

Use generic constraints when you want to write flexible code that works with many types but still needs to be sure those types have certain features. For example, if you write a method that sorts items, you might require the items to be comparable so the method knows how to order them.

In real life, this is like saying you want to borrow a tool that can only be used for a specific job. It helps avoid mistakes and makes your code easier to understand and maintain. Common use cases include ensuring types implement interfaces like IComparable, inherit from a base class, or have a default constructor.

Key Points

• Generic constraints limit what types can be used with generics.
• They ensure the type has certain capabilities or features.
• Common constraints include base class, interface, constructor, and value type.
• They help prevent errors and make code safer and clearer.

Key Takeaways

Generic constraints restrict types to ensure safe and predictable code.

They allow using specific methods or properties of the constrained type.

Use constraints to enforce interfaces, base classes, or constructors.

Constraints improve code clarity and reduce runtime errors.