Type parameter constraints in C# specify requirements on generic type arguments, ensuring they meet particular criteria for safety and functionality. These constraints enable the compiler to validate operations within generic code, allowing methods or properties dependent on specific conditions to be invoked securely.

Key constraints supported in C# include:

Reference Type Constraint

where T : class

This requires T to be a reference type, such as a class or interface, excluding value types.

Value Type Constraint

where T : struct

Specifies that T must be a non-nullable value type. This implicitly includes a parameterless constructor, making an explicit new() constraint redundant.

Parameterless Constructor Constraint

where T : new()

Ensures T has a public parameterless constructor, permitting instantiation via new T().

Inetrface Constraint

where T : IComparable

Or with multiple enterfaces:

where T : ISerializable, IComparable<T>

Mandates that T implements the specified interface(s).

Base Clas Constraint

where T : BaseClass

Requires T to derive from a particular base class.

Non-nullable Constraint (C# 8.0+)

where T : notnull

Indicates T cannot be null, applicable to reference types.

Unmanaged Constraint (C# 7.3+)

where T : unmanaged

Restricts T to unmanaged types, which are value types without managed references, like integers or pointers.

Constraints are defined using the where keyword in generic declarations. For example:

public class GenericContainer<T> where T : IEquatable<T>, new()
{
    public T GenerateItem() => new T();
    public bool CheckEquality(T item) => item?.Equals(default(T)) ?? false;
}

Here, T must implement IEquatable<T> and have a parameterless constructor, enabling safe instantiation and equality comparisons within the class.