Constraints in C# Generics

What are Constraints in C# Generics?

**Constraints** in C# generics are used to specify the type requirements for generic parameters. Constraints restrict the types that can be used with a generic class, method, or interface, ensuring type safety and better performance.

Key Features of Constraints

• Ensures **type safety** by restricting generic types.
• Improves **performance** by avoiding unnecessary boxing and unboxing.
• Supports multiple constraints on a single generic type.
• Used in **generic classes, methods, interfaces, and delegates**.

Types of Constraints in C#

Below are different types of constraints used in C# generics:

Using Reference Type Constraints (where T : class)

Ensures that the generic type is a **reference type** (e.g., string, object, custom classes).

Example: Reference Type Constraint

using System;

class ReferenceTypeExample where T : class
{
    public T Value { get; set; }

    public ReferenceTypeExample(T value)
    {
        Value = value;
    }

    public void Display()
    {
        Console.WriteLine($"Value: {Value}");
    }
}

// Usage
class Program
{
    static void Main()
    {
        ReferenceTypeExample example = new ReferenceTypeExample("Hello Generics");
        example.Display();

        // ReferenceTypeExample errorExample = new ReferenceTypeExample(100); // Error: 'int' is not a reference type
    }
}

// Output:
// Value: Hello Generics
        

The **class constraint** ensures that only reference types (like strings) can be used.

Using Value Type Constraints (where T : struct)

Ensures that the generic type is a **value type** (e.g., int, double, bool).

Example: Value Type Constraint

using System;

class ValueTypeExample where T : struct
{
    public T Value { get; set; }

    public ValueTypeExample(T value)
    {
        Value = value;
    }

    public void Display()
    {
        Console.WriteLine($"Value: {Value}");
    }
}

// Usage
class Program
{
    static void Main()
    {
        ValueTypeExample example = new ValueTypeExample(42);
        example.Display();

        // ValueTypeExample errorExample = new ValueTypeExample("Hello"); // Error: 'string' is not a value type
    }
}

// Output:
// Value: 42
        

The **struct constraint** ensures that only value types (like integers) can be used.

Using Multiple Constraints

Multiple constraints can be combined to enforce **stronger type restrictions**.

Example: Applying Multiple Constraints

using System;

class MultiConstraintExample where T : class, new()
{
    public T Instance { get; set; } = new T();
}

// Usage
class SampleClass { }

class Program
{
    static void Main()
    {
        MultiConstraintExample example = new MultiConstraintExample();
        Console.WriteLine("Instance created successfully.");
    }
}

// Output:
// Instance created successfully.
        

This example ensures that **T is a reference type** and **has a parameterless constructor**.

Best Practices for Using Constraints

• Use constraints to **ensure type safety** when working with generics.
• Apply **interface constraints** to enforce method contracts.
• Use the **new() constraint** when an instance needs to be created within the class.
• Limit **multiple constraints** to avoid unnecessary complexity.