This code compiles but throws ArrayTypeMismatchException at run time: object[] items = new string[3]; items[0] = 42;. Explain array covariance in C#, why it exists, what it costs, and how generic variance and read-only interfaces avoid the problem.

1. The IL and the runtime check

Storing into a reference-type array uses stelem.ref (or stelem with a reference type token). The JIT expands it into a call to a helper (CORINFO_HELP_ARRADDR_ST / StelemRef), which roughly does:

if (value == null) store; return;
elementType = array.MethodTable.ElementType;
if (value.MethodTable == elementType) store; return;     // fast path: exact match
if (elementType == typeof(object)) store; return;         // object[] accepts anything
if (IsAssignable(value.MethodTable, elementType)) store; // slow path: walk hierarchy / interfaces / cast cache
else throw ArrayTypeMismatchException;

The helper also performs the GC write barrier that every reference store needs. For value-type arrays (int[]), there is no covariance check and no write barrier.

2. When the JIT removes the check

• If the array's static type is T[] where T is sealed (e.g. string[]), the actual array can only be string[], so any string store is safe; the JIT can skip the type check.
• If the array was just created with new T[n] in the same method, its exact type is known.
• If the value being stored is null.
• If the value comes from the same array (e.g. swapping elements in a sort).

That's why sorting or shuffling a string[] is cheap, but writing arbitrary objects to an object[] that might be a covariant view is not.

3. Covariance and Span<T> / Memory<T>

object[] arr = new string[3];
var span = new Span<object>(arr);   // throws ArrayTypeMismatchException
ReadOnlySpan<object> ro = arr;      // OK - read-only, no writes possible

Writable spans write elements with plain memory stores (no per-element check), so the constructor validates up front that arr.GetType() == typeof(object[]). This means some code paths throw just from creating a span over a covariant array, even if you never write.

4. Value-type array oddities

The CLR allows reinterpretation between same-size integral arrays of different signedness:

object o = new int[] { -1 };
uint[] u = (uint[])o;          // allowed by the CLR! u[0] == 4294967295

C# rejects (uint[])new int[1] at compile time, but casting through object succeeds at run time. Enum arrays and their underlying integer arrays are similarly interchangeable. These are rarely used intentionally but can surprise in reflection-heavy code.

5. Variance rules for generics (how C# keeps them safe)

• Variance annotations (out, in) are only allowed on interface and delegate type parameters, not classes or structs.
• An out T parameter may appear only in output positions (return types, get accessors, out T in other covariant interfaces).
• An in T parameter may appear only in input positions.
• Variance applies only to reference type arguments: IEnumerable<int> is not convertible to IEnumerable<object>, because that would require boxing each element.
• The compiler verifies these rules at the declaration (CS1961), so uses can never break type safety.

The classic example of contravariance: an IComparer<object> can be used where an IComparer<string> is expected, because anything that compares objects can compare strings.

6. Arrays and generic interfaces

SZ arrays implement IList<T>, IReadOnlyList<T> and friends through runtime magic (SZArrayHelper). Because of array covariance, a string[] also "implements" IList<object>, and writing through that interface triggers the same runtime check. Calling Add on an array via IList<T> throws NotSupportedException, because arrays are fixed-size. These are more reasons not to expose arrays as IList<T>.

Try it yourself

1. Run the failing snippet and read the stack trace.
2. Benchmark writing object values into a real object[] vs into object[] arr = new string[n] (storing strings) with BenchmarkDotNet.
3. Try new Span<object>(new string[1]) and ReadOnlySpan<object> r = new string[1];.
4. Declare an interface IProducer<out T> { void Accept(T value); } and read CS1961.

namespace Arrays;

public abstract class Animal { public abstract string Sound { get; } }
public sealed class Dog : Animal { public override string Sound => "Woof"; }
public sealed class Cat : Animal { public override string Sound => "Meow"; }

public static class Covariance
{
    public static void Main()
    {
        // 1. Covariant array, checked writes
        object[] items = new string[3];
        items[0] = "ok";
        try
        {
            items[1] = 42;
        }
        catch (ArrayTypeMismatchException)
        {
            Console.WriteLine($"Array is really {items.GetType().Name}");   // String[]
        }

        // 2. Base-type array that is really a Dog[]
        Animal[] animals = new Dog[2];
        animals[0] = new Dog();
        try { animals[1] = new Cat(); }
        catch (ArrayTypeMismatchException) { Console.WriteLine("Cannot store a Cat in a Dog[]"); }

        // 3. Span constructor also checks
        try { _ = new Span<Animal>(animals); }
        catch (ArrayTypeMismatchException) { Console.WriteLine("Writable span refused"); }
        ReadOnlySpan<Animal> readOnly = animals;            // fine: cannot write

        // 4. Safe alternative: generic covariance on read-only interfaces
        List<Dog> dogs = [new Dog(), new Dog()];
        IReadOnlyList<Animal> view = dogs;                  // allowed, cannot add a Cat
        PrintAll(view);
        // List<Animal> wrong = dogs;                       // compile error: List<T> is invariant
    }

    private static void PrintAll(IEnumerable<Animal> animals)
    {
        foreach (var a in animals) Console.WriteLine(a.Sound);
    }
}