All 17 Generics questions
More in Generics
What is covariance and contravariance in generics? Why can't you use operators like + directly on an unconstrained generic T? How do generic type constraints ('where T : ...') restrict what types can be used, and what are the common constraint kinds? How does generic type inference work when calling a generic method, and when do you need to specify the type argument explicitly? What are generics in C#, and what specific problems do they solve compared to writing type-specific code? How are generics implemented for value types vs reference types in the CLR? What problem do generic math / static abstract interface members solve? How would you implement a generic method with MULTIPLE type parameters and constraints that reference EACH OTHER, like a generic mapping function? How do generic type parameters interact with static members, and why does each closed generic type get its OWN independent set of static field values? How would you implement a generic, reusable object pool using generic constraints to ensure poolable objects can be properly reset?
Advertisement
Back to results for “Generics”
C# › Generics

What is covariance ('out T') and contravariance ('in T') in generic interfaces, and how does IEnumerable<out T> demonstrate covariance?

Intermediate

Answer

Covariance ('out T') allows a generic interface with a type parameter used only in OUTPUT positions (return values) to be treated as its LESS specific base type automatically — e.g., IEnumerable<Dog> can be used where IEnumerable<Animal> is expected, since you can only READ Dogs out of it as Animals safely; contravariance ('in T') is the reverse, for type parameters used only in INPUT positions.
IEnumerable<string> strings = new List<string> { "a", "b" };
IEnumerable<object> objects = strings; // OK! covariant: IEnumerable<out T> allows this

// Contravariance example:
Action<object> objectAction = obj => Console.WriteLine(obj);
Action<string> stringAction = objectAction; // OK! contravariant: Action<in T> allows this
Real-world example Understanding why you can assign an IEnumerable<Dog> directly to an IEnumerable<Animal>-typed variable without any explicit conversion.

Common follow-ups: Why can't a MUTABLE generic interface like IList<T> be covariant the same way IEnumerable<T> is?

Interfaces & Abstract Classes
All 17 Generics questions