What is covariance in C# generics? Explain the out modifier, why IEnumerable<string> converts to IEnumerable<object> but List<string> does not convert to List<object>, which BCL types are covariant, and the rules a covariant type parameter must follow.

1. How variance works at run time

Variance is supported by the CLR, not just the compiler. An interface type IEnumerable<string> is a different type from IEnumerable<object>, but the runtime's casting logic knows IEnumerable<out T> is covariant and that string is a reference type assignable to object, so the cast succeeds with no conversion — the same object reference is reused. That's why it's restricted to reference types: a string reference is already a valid object reference; an int value isn't an object without boxing.

Variance checks make some casts slightly more expensive (the runtime has to consider variant compatibility), but the casting cache makes repeated casts fast.

2. Variance validity rules (formal)

The compiler classifies positions as covariant (output), contravariant (input) or invariant:

• A return type is covariant.
• A parameter type is contravariant.
• If I<out U> is used in a covariant position, its argument position is covariant; if I<in U>, its argument position flips.
• ref/out parameters are invariant.

An out T must appear only in covariant positions after this flipping. E.g. void Register(Action<T> callback) in IFoo<out T> is valid: Action<in T> flips the parameter position back to covariant.

3. Covariance and delegates

Func<string> getString = () => "hi";
Func<object> getObject = getString;   // covariant in TResult

Besides generic variance, C# also has method group variance: a method returning string can be assigned to a Func<object> delegate.

4. Arrays: unsafe covariance

Arrays are covariant for reference types (string[] to object[]), but they're mutable — so the runtime checks every write (ArrayTypeMismatchException). Generic variance avoided that design mistake by allowing variance only where it's statically safe.

5. Why Task<T> isn't covariant

Task<T> is a class, and class type parameters can't be variant in .NET. So Task<Dog> can't be returned where Task<Animal> is expected; you must await and return, or use ValueTask/Task.FromResult<Animal>. (There have been proposals for covariant tasks via interfaces like ITask<out T> in libraries.)

6. Designing covariant interfaces

Split read and write interfaces so the read side can be covariant:

public interface IReadStore<out T> { T Get(int id); }
public interface IWriteStore<in T> { void Put(int id, T value); }
public interface IStore<T> : IReadStore<T>, IWriteStore<T> { }

Consumers that only read can accept IReadStore<Animal> and be given an IStore<Dog>.

Try it yourself

1. Assign List<string> to IEnumerable<object> and to List<object>; read the error for the second.
2. Try IEnumerable<int> to IEnumerable<object>.
3. Declare interface IProducer<out T> { void Accept(T value); } and read CS1961.
4. Split a store interface into read/write parts and use covariance on the read side.

namespace Generics.Covariance;

public abstract record ReportRow(string Label);
public sealed record SalesRow(string Label, decimal Amount) : ReportRow(Label);

public interface IRowSource<out TRow> where TRow : ReportRow
{
    TRow First();
    IEnumerable<TRow> All();
}

public sealed class SalesSource(IReadOnlyList<SalesRow> rows) : IRowSource<SalesRow>
{
    public SalesRow First() => rows[0];
    public IEnumerable<SalesRow> All() => rows;
}

public static class Exporter
{
    public static void Export(IReadOnlyList<ReportRow> rows)
    {
        foreach (var row in rows) Console.WriteLine(row.Label);
    }

    public static void ExportFrom(IRowSource<ReportRow> source)
    {
        foreach (var row in source.All()) Console.WriteLine($"source: {row.Label}");
    }
}

public static class Program
{
    public static void Main()
    {
        List<SalesRow> sales = [new("Jan", 100m), new("Feb", 150m)];

        Exporter.Export(sales);                        // IReadOnlyList<SalesRow> -> IReadOnlyList<ReportRow>, no copy
        Exporter.ExportFrom(new SalesSource(sales));   // IRowSource<SalesRow> -> IRowSource<ReportRow>

        Func<SalesRow> makeSales = () => new SalesRow("Mar", 90m);
        Func<ReportRow> makeRow = makeSales;           // delegate covariance
        Console.WriteLine(makeRow().Label);

        IEnumerable<object> objects = sales;            // reference types: OK
        // IEnumerable<object> boxed = new List<int>(); // CS0266: value types are not variant
        IEnumerable<object> boxed = new List<int> { 1, 2 }.Cast<object>();
        Console.WriteLine(objects.Count() + boxed.Count());
    }
}