Understanding Generic Constraints in C#

public class GenericStruct<T> where T : struct
{
    private T _value;

    public GenericStruct(T value)
    {
        _value = value;
    }

    public T GetValue()
    {
        return _value;
    }

    public void SetValue(T value)
    {
        _value = value;
    }
}

var genericStruct = new GenericStruct<int>(10);
Console.WriteLine($"Value: {genericStruct.GetValue()}"); // Output: Value: 10

public class GenericClass<T> where T : class
{
    private T _instance;

    public GenericClass(T instance)
    {
        _instance = instance;
    }

    public T GetInstance()
    {
        return _instance;
    }

    public void SetInstance(T instance)
    {
        _instance = instance;
    }
}

var genericClass = new GenericClass<string>("Hello");
Console.WriteLine($"Instance: {genericClass.GetInstance()}"); // Output: Instance: Hello

public class GenericWithConstructor<T> where T : new()
{
    private T _instance;

    public GenericWithConstructor()
    {
        _instance = new T();
    }

    public T GetInstance()
    {
        return _instance;
    }
}

var genericWithConstructor = new GenericWithConstructor<MyClass>();
Console.WriteLine($"Instance: {genericWithConstructor.GetInstance().Name}"); // Assuming MyClass has a Name property

public class Animal { }

public class Dog : Animal { }

public class GenericWithBaseClass<T> where T : Animal
{
    private T _animal;

    public GenericWithBaseClass(T animal)
    {
        _animal = animal;
    }

    public T GetAnimal()
    {
        return _animal;
    }
}

var genericWithBaseClass = new GenericWithBaseClass<Dog>(new Dog());
Console.WriteLine($"Animal: {genericWithBaseClass.GetAnimal()}"); // Output: Animal: Dog

5. where T: <interface>

The interface constraint ensures that the type parameter implements a specific interface.

public interface IShape
{
    void Draw();
}

public class Circle : IShape
{
    public void Draw()
    {
        Console.WriteLine("Drawing Circle");
    }
}

public class GenericWithInterface<T> where T : IShape
{
    private T _shape;

    public GenericWithInterface(T shape)
    {
        _shape = shape;
    }

    public void DrawShape()
    {
        _shape.Draw();
    }
}

var genericWithInterface = new GenericWithInterface<Circle>(new Circle());
genericWithInterface.DrawShape(); // Output: Drawing Circle

6. where T: unmanaged

The unmanaged constraint ensures that the type parameter is an unmanaged type, which includes simple types like int, float, char, pointers, and enums.

public class GenericUnmanaged<T> where T : unmanaged
{
    private T _value;

    public GenericUnmanaged(T value)
    {
        _value = value;
    }

    public T GetValue()
    {
        return _value;
    }

    public void SetValue(T value)
    {
        _value = value;
    }
}

var genericUnmanaged = new GenericUnmanaged<int>(42);
Console.WriteLine($"Value: {genericUnmanaged.GetValue()}"); // Output: Value: 42

7. where T: <type parameter name>

This constraint ensures that the type parameter is the same as or inherits from another type parameter.

public class GenericWithTypeParam<T, U> where T : U
{
    private T _value;

    public GenericWithTypeParam(T value)
    {
        _value = value;
    }

    public T GetValue()
    {
        return _value;
    }

    public void SetValue(T value)
    {
        _value = value;
    }
}

// Usage
public class MyBaseClass { }
public class MyClass : MyBaseClass { }

var genericWithTypeParam = new GenericWithTypeParam<MyClass, MyBaseClass>(new MyClass());
Console.WriteLine($"Value: {genericWithTypeParam.GetValue()}"); // Output: Value: MyClass instance

8. where T: class, new()

This constraint ensures that the type parameter is a reference type and has a public parameterless constructor.

public class MyClass
{
    public string Name { get; set; }

    public MyClass()
    {
        Name = "Default";
    }
}

public class GenericWithMultipleTypes<T> where T : class, new()
{
    private T _value;

    public GenericWithMultipleTypes()
    {
        _value = new T();
    }

    public T GetValue()
    {
        return _value;
    }

    public void SetValue(T value)
    {
        _value = value;
    }
}

var genericWithMultipleTypes = new GenericWithMultipleTypes<MyClass>();
Console.WriteLine($"Initial Value: {genericWithMultipleTypes.GetValue().Name}"); // Output: Initial Value: Default

var newMyClass = new MyClass { Name = "Updated" };
genericWithMultipleTypes.SetValue(newMyClass);
Console.WriteLine($"New Value: {genericWithMultipleTypes.GetValue().Name}"); // Output: New Value: Updated

Github Project Link

• https://github.com/SardarMudassarAliKhan/GenericsInCSharpCompleteExample

Conclusion

Generic constraints in C# are powerful tools that allow you to enforce certain conditions on the types used with your generic classes, methods, and interfaces. By using constraints like struct, class, new(), and others, you can ensure that your generic code is both flexible and type-safe, allowing for more robust and maintainable applications.