Generics

// A generic class.
public class Box<T>
{
    private T? _value;

    public void Put(T value) => _value = value;
    public T? Take() => _value;
    public bool HasValue => _value is not null;
}

// A generic struct.
public readonly struct Pair<TFirst, TSecond>(TFirst first, TSecond second)
{
    public TFirst First { get; } = first;
    public TSecond Second { get; } = second;
    public override string ToString() => $"({First}, {Second})";
}

// A generic interface.
public interface IRepository2<TEntity, TKey>
{
    TEntity? Find(TKey key);
    void Save(TKey key, TEntity entity);
}

// A generic delegate.
public delegate TResult Transform<in TInput, out TResult>(TInput input);

// A generic method on a non-generic type.
public static class Utility
{
    public static void Swap<T>(ref T left, ref T right) => (left, right) = (right, left);

    public static T[] Repeat<T>(T value, int count)
    {
        var result = new T[count];
        Array.Fill(result, value);
        return result;
    }
}

public static class InferenceDemo
{
    public static void Run()
    {
        int a = 1, b = 2;
        Utility.Swap(ref a, ref b);              // T inferred as int
        Console.WriteLine($"{a} {b}");

        string[] words = Utility.Repeat("x", 3); // T inferred from the first argument
        Console.WriteLine(words.Length);

        // Explicit when inference cannot help (the return type is never used to infer).
        var empty = Utility.Repeat<double>(0, 0);
        Console.WriteLine(empty.Length);

        // A generic *type* always needs its arguments -- but `new()` is target-typed.
        Box<string> box = new();
        var pair = new Pair<int, string>(1, "one");
        Console.WriteLine($"{box.HasValue} {pair}");
    }
}

public static class Pair
{
    public static Pair<TFirst, TSecond> Of<TFirst, TSecond>(TFirst first, TSecond second)
        => new(first, second);
}
// var p = Pair.Of(1, "one");   // Pair<int, string>, inferred

public static class Constrained
{
    // struct: no null, and `T?` means Nullable<T>.
    public static T? FirstOrNull<T>(IEnumerable<T> source) where T : struct
    {
        foreach (T item in source)
        {
            return item;
        }
        return null;
    }

    // new(): the method can construct one.
    public static T CreateAndConfigure<T>(Action<T> configure) where T : new()
    {
        var instance = new T();
        configure(instance);
        return instance;
    }

    // Interface constraints compose, and give access to the members.
    public static T Largest<T>(IEnumerable<T> source) where T : IComparable<T>
    {
        using IEnumerator<T> enumerator = source.GetEnumerator();
        if (!enumerator.MoveNext())
        {
            throw new ArgumentException("Empty sequence.", nameof(source));
        }

        T best = enumerator.Current;
        while (enumerator.MoveNext())
        {
            if (enumerator.Current.CompareTo(best) > 0)
            {
                best = enumerator.Current;
            }
        }
        return best;
    }

    // unmanaged: safe to take the size of and copy as raw bytes.
    public static int SizeOf<T>() where T : unmanaged => Unsafe.SizeOf<T>();

    // Several constraints on several parameters.
    public static TResult Map<TSource, TResult>(TSource source, Func<TSource, TResult> selector)
        where TSource : notnull
        where TResult : class, new()
        => selector(source);
}

public static class Reification
{
    public static void Run()
    {
        var ints = new List<int>();
        var strings = new List<string>();

        Console.WriteLine(ints.GetType());               // System.Collections.Generic.List`1[System.Int32]
        Console.WriteLine(ints.GetType() == strings.GetType());   // False -- distinct types

        // Type arguments are recoverable at run time.
        Type[] arguments = ints.GetType().GetGenericArguments();
        Console.WriteLine(arguments[0]);                 // System.Int32

        // `typeof(T)` works inside a generic method -- impossible with erasure.
        Console.WriteLine(NameOf<DateTime>());           // DateTime
    }

    private static string NameOf<T>() => typeof(T).Name;
}

public class Animal2 { public string Name { get; init; } = ""; }
public class Dog2 : Animal2 { }

// `out T`: covariant. T appears only in OUTPUT positions (return types).
public interface IProducer<out T>
{
    T Produce();
}

// `in T`: contravariant. T appears only in INPUT positions (parameters).
public interface IConsumer<in T>
{
    void Consume(T item);
}

public sealed class DogProducer : IProducer<Dog2>
{
    public Dog2 Produce() => new() { Name = "Rex" };
}

public sealed class AnimalConsumer : IConsumer<Animal2>
{
    public void Consume(Animal2 item) => Console.WriteLine($"consumed {item.Name}");
}

public static class VarianceDemo
{
    public static void Run()
    {
        // Covariance: a producer of Dogs IS a producer of Animals.
        IProducer<Animal2> producer = new DogProducer();
        Console.WriteLine(producer.Produce().Name);

        // Contravariance: a consumer of Animals IS a consumer of Dogs.
        IConsumer<Dog2> consumer = new AnimalConsumer();
        consumer.Consume(new Dog2 { Name = "Fido" });

        // The BCL uses both heavily.
        IEnumerable<Dog2> dogs = [new Dog2 { Name = "A" }];
        IEnumerable<Animal2> animals = dogs;          // IEnumerable<out T>
        Console.WriteLine(animals.Count());

        Comparison<Animal2> byName = (x, y) => string.CompareOrdinal(x.Name, y.Name);
        Comparison<Dog2> dogComparison = byName;      // Comparison<in T>
        Console.WriteLine(dogComparison(new Dog2(), new Dog2()));
    }
}

public class Counter<T>
{
    public static int Count;

    static Counter() => Console.WriteLine($"static ctor for Counter<{typeof(T).Name}>");

    public Counter() => Count++;
}

public static class StaticsDemo
{
    public static void Run()
    {
        _ = new Counter<int>();
        _ = new Counter<int>();
        _ = new Counter<string>();

        Console.WriteLine(Counter<int>.Count);      // 2
        Console.WriteLine(Counter<string>.Count);   // 1 -- a separate field
    }
}

public static class Statistics
{
    public static T Sum<T>(ReadOnlySpan<T> values) where T : INumber<T>
    {
        T total = T.Zero;
        foreach (T value in values)
        {
            total += value;
        }
        return total;
    }

    public static T Mean<T>(ReadOnlySpan<T> values) where T : INumber<T>
        => values.IsEmpty ? T.Zero : Sum(values) / T.CreateChecked(values.Length);

    public static void Demo()
    {
        Console.WriteLine(Mean<double>([1, 2, 3, 4]));      // 2.5
        Console.WriteLine(Mean<decimal>([1m, 2m]));         // 1.5
        Console.WriteLine(Sum<int>([1, 2, 3]));             // 6
    }
}

public static class OpenTypes
{
    public static void Run()
    {
        Type open = typeof(List<>);                 // note the empty <>
        Type closed = typeof(List<int>);

        Console.WriteLine(open.IsGenericTypeDefinition);   // True
        Console.WriteLine(closed.IsGenericTypeDefinition); // False
        Console.WriteLine(open.GetGenericArguments().Length);   // 1

        // Close an open type reflectively -- the basis of most DI containers.
        Type constructed = open.MakeGenericType(typeof(string));
        object? instance = Activator.CreateInstance(constructed);
        Console.WriteLine(instance?.GetType());     // List`1[System.String]

        Console.WriteLine(typeof(Dictionary<,>).GetGenericArguments().Length);   // 2

        // C# 14: nameof accepts an unbound generic.
        Console.WriteLine(nameof(List<>));          // List
    }
}