C# Variance — Why Array Store Checks Crash Production Loops

namespace io.thecodeforge.covariance;

using System;
using System.Collections.Generic;

public class Animal
{
    public string Name { get; init; }
    public Animal(string name) => Name = name;
    public override string ToString() => $"Animal({Name})";
}

public class Dog : Animal
{
    public Dog(string name) : base(name) { }
    public override string ToString() => $"Dog({Name})";
}

public class Cat : Animal
{
    public Cat(string name) : base(name) { }
    public override string ToString() => $"Cat({Name})";
}

class VarianceMotivation
{
    static void Main()
    {
        // --- WHY List<Dog> cannot be List<Animal> ---
        List<Dog> dogPack = new() { new Dog("Rex"), new Dog("Buddy") };

        // This line does NOT compile — List<T> is INVARIANT.
        // If it did compile, the next line would corrupt the list at runtime.
        // List<Animal> animals = dogPack;  // CS0029 — cannot implicitly convert
        // animals.Add(new Cat("Whiskers")); // Rex and Buddy would be very upset

        // --- BUT IEnumerable<Dog> CAN be used as IEnumerable<Animal> ---
        // IEnumerable<T> is COVARIANT (out T), so this is safe and legal.
        // We can only READ from IEnumerable — we can never Add to it.
        // Therefore the Cat-corruption scenario is impossible.
        IEnumerable<Animal> safeAnimals = dogPack; // compiles just fine

        Console.WriteLine("Safe covariant assignment succeeded.");
        foreach (Animal animal in safeAnimals)
        {
            // Each element is still a Dog at runtime — covariance preserves identity.
            // The variable type is Animal, but GetType() proves the real type survived.
            Console.WriteLine($"  {animal} — runtime type: {animal.GetType().Name}");
        }
    }
}

namespace io.thecodeforge.covariance;

using System;
using System.Collections.Generic;

// --- Covariant interface: T only flows OUT ---
// The 'out' keyword tells the compiler: this interface only produces T values.
// It can never accept a T as an argument, so widening is provably safe.
public interface IAnimalProducer<out TAnimal> where TAnimal : Animal
{
    TAnimal Produce();                           // Legal: T in return position (output)
    IEnumerable<TAnimal> ProduceBatch(int count); // Legal: T inside a covariant wrapper
    // void Accept(TAnimal animal);              // ILLEGAL — CS1961, T in input position
}

public class DogBreeder : IAnimalProducer<Dog>
{
    private readonly string[] _names = { "Apollo", "Bella", "Caesar" };
    private int _index = 0;

    public Dog Produce() => new Dog(_names[_index++ % _names.Length]);

    public IEnumerable<Dog> ProduceBatch(int count)
    {
        for (int i = 0; i < count; i++)
            yield return Produce();
    }
}

public class RescueShelter : IAnimalProducer<Cat>
{
    public Cat Produce() => new Cat("Rescue-" + Guid.NewGuid().ToString()[..4]);

    public IEnumerable<Cat> ProduceBatch(int count)
    {
        for (int i = 0; i < count; i++)
            yield return Produce();
    }
}

class CovariantProducer
{
    // This method accepts any IAnimalProducer<Animal>.
    // Because of covariance, we can pass an IAnimalProducer<Dog> or IAnimalProducer<Cat>.
    static void DisplayThreeAnimals(IAnimalProducer<Animal> producer)
    {
        Console.WriteLine($"Producer type: {producer.GetType().Name}");
        foreach (Animal animal in producer.ProduceBatch(3))
        {
            // Runtime type is preserved — covariance does not erase the concrete type.
            // The variable is typed as Animal, but GetType() returns the real class.
            Console.WriteLine($"  Got: {animal} [{animal.GetType().Name}]");
        }
    }

    static void Main()
    {
        IAnimalProducer<Dog> dogBreeder = new DogBreeder();
        IAnimalProducer<Cat> rescueShelter = new RescueShelter();

        // Covariant assignment: IAnimalProducer<Dog> → IAnimalProducer<Animal>
        // This compiles ONLY because TAnimal is marked 'out'.
        IAnimalProducer<Animal> animalSource = dogBreeder;

        DisplayThreeAnimals(dogBreeder);     // passes directly
        DisplayThreeAnimals(rescueShelter);  // Cat producer accepted as Animal producer
        DisplayThreeAnimals(animalSource);   // the explicitly widened reference
    }
}

namespace io.thecodeforge.covariance;

using System;
using System.Collections.Generic;

// --- Contravariant interface: T only flows IN ---
// The 'in' keyword means this interface only CONSUMES T values.
// Therefore a handler of Animal can safely act as a handler of Dog.
public interface IAnimalProcessor<in TAnimal> where TAnimal : Animal
{
    void Process(TAnimal animal);                  // Legal: T in parameter (input position)
    void ProcessBatch(IEnumerable<TAnimal> batch); // Legal: T inside an input parameter
    // TAnimal Retrieve();                         // ILLEGAL — CS1962, T in output position
}

// A general processor that handles ANY animal
public class AnimalHealthChecker : IAnimalProcessor<Animal>
{
    public void Process(Animal animal)
    {
        // Works on any Animal — so it works on Dog and Cat too.
        // The concrete type is visible at runtime even through the contravariant interface.
        Console.WriteLine($"  Health check passed for {animal} [{animal.GetType().Name}]");
    }

    public void ProcessBatch(IEnumerable<Animal> batch)
    {
        foreach (Animal animal in batch)
            Process(animal);
    }
}

// A specific processor that only handles Dogs
public class DogTrainer : IAnimalProcessor<Dog>
{
    public void Process(Dog dog)
    {
        Console.WriteLine($"  Training session for {dog}");
    }

    public void ProcessBatch(IEnumerable<Dog> batch)
    {
        foreach (Dog dog in batch)
            Process(dog);
    }
}

class ContravariantProcessor
{
    // This method expects something that processes Dogs specifically.
    // Because IAnimalProcessor<in TAnimal> is contravariant, the general
    // AnimalHealthChecker is accepted here — it handles any Animal, so Dogs are fine.
    static void RunDogPipeline(IAnimalProcessor<Dog> dogProcessor, IEnumerable<Dog> dogs)
    {
        Console.WriteLine($"  Using processor: {dogProcessor.GetType().Name}");
        dogProcessor.ProcessBatch(dogs);
    }

    static void Main()
    {
        var dogPack = new List<Dog> { new Dog("Max"), new Dog("Luna") };

        IAnimalProcessor<Animal> generalChecker = new AnimalHealthChecker();
        IAnimalProcessor<Dog> specificTrainer = new DogTrainer();

        // Contravariant assignment: IAnimalProcessor<Animal> → IAnimalProcessor<Dog>
        // This flows OPPOSITE to inheritance: Animal is broader than Dog,
        // yet the Animal processor is assignable to the Dog processor slot.
        // Safe because: anything a Dog processor is asked to handle IS an Animal.
        IAnimalProcessor<Dog> checkerAsDogProcessor = generalChecker; // compiles cleanly

        Console.WriteLine("Running with specific DogTrainer:");
        RunDogPipeline(specificTrainer, dogPack);

        Console.WriteLine("Running with general AnimalHealthChecker (contravariant):");
        RunDogPipeline(generalChecker, dogPack);        // general processor passed directly
        RunDogPipeline(checkerAsDogProcessor, dogPack); // explicit contravariant reference
    }
}

namespace io.thecodeforge.covariance;

using System;

class DelegateAndArrayVariance
{
    // --- Method group covariance ---
    // Returns Dog (more specific), compatible with Func<Animal> (more general).
    // This works because Dog IS-AN Animal — covariance flows with inheritance.
    static Dog CreateDog() => new Dog("Scout");

    // --- Method group contravariance ---
    // Accepts Animal (more general), compatible with Action<Dog> (more specific).
    // This works because Dog IS-AN Animal — the method can handle any Animal,
    // so it can certainly handle a Dog.
    static void LogAnimal(Animal animal)
        => Console.WriteLine($"  [LOG] {animal} ({animal.GetType().Name})");

    static void Main()
    {
        // DELEGATE COVARIANCE — method group assignment
        // CreateDog returns Dog; Dog IS-AN Animal; so Func<Animal> can hold it.
        Func<Animal> animalFactory = CreateDog;
        Animal produced = animalFactory();
        Console.WriteLine($"Delegate covariance produced: {produced}");

        // DELEGATE CONTRAVARIANCE — method group assignment
        // LogAnimal accepts Animal; Dog IS-AN Animal; so a method handling any Animal
        // can handle Dogs specifically. The assignment goes against inheritance direction.
        Action<Dog> dogLogger = LogAnimal;
        dogLogger(new Dog("Ranger"));

        // THE DELEGATE VARIANCE TRAP — do not cast delegate instances directly
        Func<Dog> dogFactory = CreateDog;
        // Func<Animal> wrongWay = (Func<Animal>)dogFactory; // InvalidCastException at runtime!
        // The compiler may not always catch this. The CLR will.
        // The correct approach is to wrap the existing delegate:
        Func<Animal> rightWay = () => dogFactory();
        Console.WriteLine($"Wrapped delegate covariance: {rightWay()}");

        // --- ARRAY COVARIANCE — legal but dangerous ---
        Dog[] dogArray = { new Dog("Fido"), new Dog("Spot") };

        // Compiles fine — arrays have been covariant since C# 1.0.
        // animalArray and dogArray point to the SAME memory.
        Animal[] animalArray = dogArray;

        Console.WriteLine("\nReading through widened array reference (safe):");
        foreach (Animal a in animalArray)
            Console.WriteLine($"  {a}");

        // WRITING through the widened reference — runtime ArrayTypeMismatchException!
        // The compiler sees Animal[] and allows the assignment syntactically.
        // The CLR sees Dog[] at runtime and rejects Cat — covariant array store check.
        Console.WriteLine("\nAttempting unsafe array write...");
        try
        {
            animalArray[0] = new Cat("Mittens"); // ArrayTypeMismatchException here
        }
        catch (ArrayTypeMismatchException ex)
        {
            Console.WriteLine($"  Runtime caught it: {ex.GetType().Name}");
            Console.WriteLine("  The CLR store check fires on every write, not just bad ones.");
            Console.WriteLine("  In a tight loop this overhead is measurable.");
        }

        // The safe alternative: IReadOnlyList<out T> is genuinely covariant
        // and prevents write access through the interface entirely.
        // No store check, no exception risk, no performance overhead after construction.
        // Note: Span<T> is NOT usable here — it's a ref struct and cannot be a generic
        // type argument. Use Span<T> for stack-allocated buffer performance, not for
        // covariant abstractions.
        System.Collections.Generic.IReadOnlyList<Animal> safeView = dogArray;
        Console.WriteLine($"\nSafe covariant view via IReadOnlyList: {safeView[0]}");
        // safeView[0] = new Cat("Mittens"); // CS0200 — property or indexer is read-only
    }
}

namespace io.thecodeforge.varianceerrors;

using System;

// Shared types for this file — kept in a separate namespace to avoid
// collision with the Animal/Dog/Cat types in other examples.
public class Shape
{
    public string Kind { get; init; }
    public Shape(string kind) => Kind = kind;
    public override string ToString() => $"Shape({Kind})";
}

public class Circle : Shape
{
    public double Radius { get; init; }
    public Circle(double radius) : base("Circle") => Radius = radius;
    public override string ToString() => $"Circle(r={Radius})";
}

// CS1960 — variance keyword on a CLASS (not allowed)
// public class BadClass<out T> { }  // error CS1960

// Correct: declare variance on an INTERFACE, implement with an invariant class
public interface IShapeProducer<out TShape> where TShape : Shape
{
    TShape Produce();                 // Legal: T in return position
    // void Accept(TShape s);        // ILLEGAL — would cause CS1961
}

public class CircleFactory : IShapeProducer<Circle>
{
    private readonly double _radius;
    public CircleFactory(double radius) => _radius = radius;
    public Circle Produce() => new Circle(_radius);
}

// CS1961 — 'out' type parameter used in input position
// interface IBrokenCovariant<out T>
// {
//     void Set(T value); // error CS1961 — T in parameter, violates 'out'
// }

// CS1962 — 'in' type parameter used in output position
// interface IBrokenContravariant<in T>
// {
//     T Get(); // error CS1962 — T in return, violates 'in'
// }

// CS1961 via generic chain — covariant T inside a contravariant wrapper flips direction
// interface IProcessorChain<in T>
// {
//     Func<T> GetProducer(); // error CS1961 — Func<T> is covariant in T,
//                            // so T appears in covariant position inside a contravariant interface
// }

class VarianceErrors
{
    static void Main()
    {
        // Covariant interface: CircleFactory produces Circle,
        // which is assignable to IShapeProducer<Shape> because TShape is 'out'
        IShapeProducer<Circle> circleFactory = new CircleFactory(5.0);
        IShapeProducer<Shape> shapeFactory = circleFactory; // covariant assignment

        Shape produced = shapeFactory.Produce();
        Console.WriteLine($"Produced via covariant interface: {produced}");
        Console.WriteLine($"Runtime type preserved: {produced.GetType().Name}");

        // Delegate variance — covariance via method group
        Func<Circle> circleFunc = () => new Circle(3.14);
        Func<Shape> shapeFunc = circleFunc.Method.CreateDelegate<Func<Shape>>(circleFunc.Target);
        // Simpler equivalent when you control the source:
        // Func<Shape> shapeFunc = () => circleFunc();
        Console.WriteLine($"Delegate covariance: {shapeFunc()}");

        // Delegate contravariance — method group assignment
        Action<Shape> shapeLogger = s => Console.WriteLine($"  [LOG] {s}");
        Action<Circle> circleLogger = shapeLogger; // contravariant: Action<in T>
        circleLogger(new Circle(2.71));
    }
}