Generics: Constraints, Variance & Advanced Use Cases

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        // THE OLD WAY (before generics): store everything as 'object'.
        // 'object' is the base type of EVERYTHING, so a list of object
        // can hold anything — but that flexibility costs you safety.
        var oldList = new List<object>();
        oldList.Add(42);          // an int gets BOXED into an object (heap alloc)
        oldList.Add("hello");     // oops — nothing stops mixed typ
...

using System;

class Program
{
    // 🎯 YOUR TURN — finish this generic method, then run Main.

    // A GENERIC METHOD has a type parameter <T> after its name.
    // The constraint 'where T : IComparable<T>' guarantees T has CompareTo,
    // so we can compare any two values of the same type.
    static T Max<T>(T a, T b) where T : ___   // 👉 IComparable<T>
    {
        // CompareTo returns > 0 when 'a' is the bigger value.
        return a.CompareTo(b) >= 0 ? ___ : b;  // 👉 return a when 
...

using System;

// A GENERIC CLASS — Box<T> can hold a value of ANY single type T.
// Write the class once; reuse it for int, string, Product, anything.
class Box<T>
{
    private T _value;                 // the stored value, typed as T
    public bool HasValue { get; private set; }

    public void Put(T item)           // 'item' must be a T
    {
        _value = item;
        HasValue = true;
        Console.WriteLine($"Put {item} into the box.");
    }

    public T Peek() => _value;        
...

using System;

// 🎯 YOUR TURN — finish this generic Pair class, then run Main.

// A GENERIC CLASS can take MORE than one type parameter.
// Pair<TFirst, TSecond> stores two values that can be different types.
class Pair<TFirst, TSecond>
{
    public TFirst First { get; }
    public TSecond Second { get; }

    public Pair(TFirst first, TSecond second)
    {
        First = first;
        Second = ___;          // 👉 store the 'second' parameter in Second
    }

    // Swap returns a new Pair w
...

using System;

class Widget { public override string ToString() => "Widget"; }

class DataTools
{
    // where T : struct — VALUE types only (int, double, DateTime).
    // This lets you safely use T? as a nullable value type.
    static T Bigger<T>(T a, T b) where T : struct, IComparable<T>
        => a.CompareTo(b) >= 0 ? a : b;

    // where T : class — REFERENCE types only. Now T can legally be null.
    static void PrintOrNull<T>(T? item) where T : class
        => Console.WriteLine(item?.T
...

using System;
using System.Collections.Generic;

// COVARIANCE — 'out T' means T is only ever RETURNED, never accepted.
// That makes it safe to treat IProducer<Dog> as IProducer<Animal>:
// every Dog it hands out really IS an Animal.
interface IProducer<out T>
{
    T Produce();
}

class Animal { public virtual string Sound => "..."; }
class Dog : Animal { public override string Sound => "Woof!"; }

class DogFactory : IProducer<Dog>
{
    public Dog Produce() => new Dog();   // always makes a D
...

using System;

// CONTRAVARIANCE — 'in T' means T is only ever ACCEPTED, never returned.
// That makes it safe to treat IConsumer<Animal> as IConsumer<Dog>:
// something that can handle ANY animal can certainly handle a dog.
interface IConsumer<in T>
{
    void Consume(T item);
}

class Animal { public virtual string Name => "animal"; }
class Dog : Animal { public override string Name => "dog"; }

class Shelter : IConsumer<Animal>
{
    public void Consume(Animal item)
        => Console.WriteLi
...

using System;

class Program
{
    // default(T) gives you the 'zero' value for ANY type without knowing it:
    //   numbers -> 0,  bool -> false,  reference types & string -> null.
    static T FirstOrDefault<T>(T[] items)
    {
        if (items.Length == 0)
            return default(T);    // safe fallback when there's nothing to return
        return items[0];
    }

    static void Main()
    {
        int[] empty = { };
        string[] words = { "alpha", "beta" };

        // T = int  -
...