> ## Documentation Index > Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt > Use this file to discover all available pages before exploring further. # C# Covariant Type Parameter A covariant type parameter in C# allows a generic interface or delegate to use a more derived (specific) type than the one specified by the generic type argument. Denoted by the `out` contextual keyword, covariance preserves the assignment compatibility of generic types, enabling implicit reference conversions from `Generic` to `Generic`. ## Syntax and Declaration Covariance is applied at the type parameter declaration level using the `out` modifier. It is strictly limited to generic interfaces and generic delegates. ```csharp theme={"dark"} // Covariant generic interface public interface IProducer { T Produce(); // Properties can be covariant if they are read-only T CurrentItem { get; } } // Covariant generic delegate public delegate T FactoryDelegate(); ``` ## Structural Mechanics When a type parameter `T` is marked as covariant (`out T`), the C# compiler enforces strict positional validation. The type `T` is restricted to **output positions** only. However, the definition of an output position includes mathematical resolution of nested variance. **Permitted (Output Positions):** * Method return types. * `get` accessors of properties. * **Nested within contravariant types in input positions:** A covariant type parameter can appear in a method parameter list if it is nested inside a contravariant generic type (e.g., `Action`). Because an input position of an input position mathematically resolves to an output position, this is structurally valid. **Prohibited (Input Positions):** * **Direct** method parameters (e.g., `void Consume(T item)`). * `set` or `init` accessors of properties. * Generic constraints on methods within the interface. * `ref`, `in`, or `out` method parameters. * Nested within covariant types in input positions (e.g., `void Consume(IEnumerable items)`). If a covariant type parameter resolves to an input position, the compiler generates error **CS1961**. ```csharp theme={"dark"} public interface IVarianceMechanics { // VALID: Direct output position. T GetItem(); // VALID: Nested inside a contravariant type (Action). // An input position of an input position resolves to an output position. void RegisterCallback(Action callback); // ERROR CS1961: 'T' cannot be used as a direct input parameter. void Consume(T item); // ERROR CS1961: 'T' cannot be used in a writable property. T MutableItem { get; set; } } ``` ## Type System Rules and Constraints 1. **Reference Types Only:** Covariance in C# is supported exclusively for reference types. It relies on implicit reference conversions at the CLR level. Value types (structs, enums, primitives like `int` or `double`) have different memory layouts and cannot be variant. ```csharp theme={"dark"} public interface ISource { T GetItem(); } public class Source : ISource { public T GetItem() => default!; } public void DemonstrateVariance() { ISource stringSource = new Source(); // Valid: string and object are reference types. ISource objectSource = stringSource; ISource intSource = new Source(); // Invalid: int is a value type. Compilation error CS0266. // ISource boxedSource = intSource; } ``` 2. **Interface and Delegate Exclusivity:** The `out` modifier cannot be applied to type parameters of classes or structs. Variance is a feature of the abstraction (interfaces/delegates), not the implementation. ```csharp theme={"dark"} // ERROR: Invalid variance modifier. Only interfaces and delegates can be variant. public class CovariantClass { } ``` 3. **Method Overloading:** While covariant type parameters cannot be used as direct method parameters, their ability to be nested within contravariant types means they *can* be used to differentiate method overloads. The compiler successfully resolves overloads based on the distinct contravariant delegate or interface signatures wrapping the covariant type parameter. ```csharp theme={"dark"} public interface IEventSource { // Valid method overloading using a covariant type parameter // nested within different contravariant types. void Subscribe(Action handler); void Subscribe(Func conditionalHandler); } ``` ## Assignment Compatibility The primary mechanical effect of a covariant type parameter is altering the compiler's type-checking rules for assignment. If `TypeD` derives from `TypeB`, and `I` is covariant, then `I` is considered a subtype of `I`. ```csharp theme={"dark"} public class BaseType { } public class DerivedType : BaseType { } public class Producer : IProducer { public T Produce() => default!; public T CurrentItem => default!; } public void AssignCovariantTypes() { // Instantiation uses the exact type IProducer derivedInstance = new Producer(); // Covariant assignment: IProducer is implicitly cast to IProducer IProducer baseInstance = derivedInstance; } ```
Tired of Poor C# Skills? Fix That With Deep Grasping! Learn More