C# Generics Explained — Type Safety, Constraints and Real-World Patterns

using System;
using System.Collections;
using System.Collections.Generic;

class BeforeAndAfterGenerics
{
    static void Main()
    {
        // ── BEFORE GENERICS ──────────────────────────────────────────
        // ArrayList stores everything as 'object' — no type safety.
        var legacyScores = new ArrayList();
        legacyScores.Add(95);          // int gets BOXED onto the heap
        legacyScores.Add(87);
        legacyScores.Add("oops");      // compiler is totally fine with this string!

        // This line compiles cleanly but throws InvalidCastException at runtime
        // because "oops" cannot be unboxed as an int.
        try
        {
            foreach (object item in legacyScores)
            {
                int score = (int)item;  // UNBOXING — risky cast every single time
                Console.WriteLine($"Legacy score: {score}");
            }
        }
        catch (InvalidCastException ex)
        {
            Console.WriteLine($"Runtime crash: {ex.Message}");
        }

        Console.WriteLine();

        // ── AFTER GENERICS ───────────────────────────────────────────
        // List<int> only accepts ints — enforced at COMPILE TIME, not runtime.
        var modernScores = new List<int>();
        modernScores.Add(95);          // stored directly, no boxing
        modernScores.Add(87);
        // modernScores.Add("oops");   // ← COMPILE ERROR: cannot convert string to int
        //                               The bug is caught before you ever run the code.

        foreach (int score in modernScores)  // no cast needed — type is already known
        {
            Console.WriteLine($"Modern score: {score}");
        }
    }
}

using System;

// A generic Result type — T is the type of the success value.
// This is a common production pattern for representing operation outcomes
// without relying on exceptions for expected failures.
public class Result<T>
{
    // The actual value when the operation succeeds.
    // Nullable because on failure there is no meaningful value.
    public T? Value { get; }        

    // Human-readable error when the operation fails.
    public string? ErrorMessage { get; }

    // Tells callers which state we're in.
    public bool IsSuccess { get; }

    // Private constructor — callers must use the factory methods below.
    // This prevents creating a Result in a half-baked state.
    private Result(T? value, string? error, bool isSuccess)
    {
        Value = value;
        ErrorMessage = error;
        IsSuccess = isSuccess;
    }

    // Factory method for the happy path.
    // The type parameter T flows through from the class to this method.
    public static Result<T> Success(T value)
        => new Result<T>(value, null, true);

    // Factory method for the failure path.
    // No value — just a descriptive error message.
    public static Result<T> Failure(string errorMessage)
        => new Result<T>(default, errorMessage, false);

    // A convenient way to pattern-match on the result.
    public override string ToString()
        => IsSuccess ? $"Success: {Value}" : $"Failure: {ErrorMessage}";
}

// ── Simulates a real service method ──────────────────────────────────────────
public class UserService
{
    // Returns Result<string> — success gives us a username, failure gives us why.
    // No exceptions thrown for normal 'user not found' cases.
    public Result<string> FindUsername(int userId)
    {
        // Simulate a simple in-memory lookup
        if (userId == 42)
            return Result<string>.Success("ada.lovelace");

        // Business-rule failure — not an exception, just a typed failure result
        return Result<string>.Failure($"No user found with ID {userId}");
    }
}

class Program
{
    static void Main()
    {
        var service = new UserService();

        // Try a valid user ID
        Result<string> found = service.FindUsername(42);
        if (found.IsSuccess)
            Console.WriteLine($"Found user: {found.Value}");   // Value is string — no cast!
        else
            Console.WriteLine($"Error: {found.ErrorMessage}");

        // Try an invalid user ID
        Result<string> notFound = service.FindUsername(99);
        Console.WriteLine(notFound);  // calls our ToString() override

        // The SAME Result<T> class works for any type — here we use int.
        // We didn't write a new class — we just changed T.
        Result<int> calculationResult = Result<int>.Success(1337);
        Console.WriteLine($"Calculation gave us: {calculationResult.Value + 1}");
    }
}

using System;
using System.Collections.Generic;

// Define a contract: anything that has an Id and can describe itself.
// This is the interface we'll use as a constraint.
public interface IEntity
{
    int Id { get; }
    string Describe();
}

// Two completely different entity types — both satisfy IEntity.
public class Product : IEntity
{
    public int Id { get; init; }
    public string Name { get; init; } = string.Empty;
    public decimal Price { get; init; }

    // Required by IEntity — gives a human-readable description.
    public string Describe() => $"Product #{Id}: {Name} at ${Price:F2}";
}

public class Employee : IEntity
{
    public int Id { get; init; }
    public string FullName { get; init; } = string.Empty;
    public string Department { get; init; } = string.Empty;

    public string Describe() => $"Employee #{Id}: {FullName} in {Department}";
}

// A generic repository constrained to IEntity.
// The 'where T : IEntity' tells the compiler that T definitely has .Id and .Describe().
// Without this constraint, accessing .Id would be a compile error.
public class InMemoryRepository<T> where T : IEntity
{
    private readonly Dictionary<int, T> _store = new();

    public void Save(T entity)
    {
        // We can access entity.Id directly — the constraint guarantees it exists.
        _store[entity.Id] = entity;
        Console.WriteLine($"Saved: {entity.Describe()}");  // .Describe() also guaranteed
    }

    public T? FindById(int id)
    {
        _store.TryGetValue(id, out T? entity);
        return entity;
    }

    public void PrintAll()
    {
        foreach (var entry in _store.Values)
            Console.WriteLine($"  → {entry.Describe()}");
    }
}

// A standalone generic method with TWO constraints on different type parameters.
// TSource must implement IEntity. TResult must have a public parameterless constructor.
// This lets us project entities into a new type we can construct on the fly.
public static class EntityMapper
{
    public static List<TResult> MapDescriptions<TSource, TResult>(
        IEnumerable<TSource> entities,
        Func<TSource, TResult> mapFunc)
        where TSource : IEntity          // constraint 1: must have IEntity members
        where TResult : new()            // constraint 2: must be constructable without args
    {
        var results = new List<TResult>();
        foreach (var entity in entities)
        {
            // mapFunc is the caller's logic — we just call it safely
            results.Add(mapFunc(entity));
        }
        return results;
    }
}

class Program
{
    static void Main()
    {
        // ── Product repository ───────────────────────────────────────
        var productRepo = new InMemoryRepository<Product>();
        productRepo.Save(new Product { Id = 1, Name = "Mechanical Keyboard", Price = 149.99m });
        productRepo.Save(new Product { Id = 2, Name = "USB-C Hub",          Price = 49.95m });

        Console.WriteLine("\nAll products:");
        productRepo.PrintAll();

        // ── Employee repository — SAME generic class, different T ────
        var employeeRepo = new InMemoryRepository<Employee>();
        employeeRepo.Save(new Employee { Id = 101, FullName = "Grace Hopper",  Department = "Engineering" });
        employeeRepo.Save(new Employee { Id = 102, FullName = "Alan Turing",   Department = "Research" });

        Console.WriteLine("\nAll employees:");
        employeeRepo.PrintAll();

        // ── Look up by ID — returns the exact type, no cast needed ───
        Product? keyboard = productRepo.FindById(1);
        Console.WriteLine($"\nFound: {keyboard?.Describe() ?? "not found"}");
    }
}

using System;
using System.Collections.Generic;

// A covariant generic interface — 'out T' means T is only ever RETURNED, never taken in.
// This is safe to widen: if you produce Cats, a caller expecting Animals is perfectly happy.
public interface IProducer<out T>
{
    T Produce();      // T appears only in output position — safe for covariance
    // void Consume(T item);  // ← would be a COMPILE ERROR with 'out T'
    //                         You can't consume a T in a covariant interface
}

// A contravariant generic interface — 'in T' means T is only ever TAKEN IN, never returned.
// Safe to narrow: if you can process any Animal, you can certainly process a Cat.
public interface IConsumer<in T>
{
    void Consume(T item);   // T appears only in input position — safe for contravariance
    // T Produce();         // ← would be a COMPILE ERROR with 'in T'
}

// A simple class hierarchy for demonstration
public class Animal
{
    public string Name { get; init; } = string.Empty;
    public virtual string Sound() => "...";
}

public class Dog : Animal
{
    public override string Sound() => "Woof";
}

// A producer of Dogs
public class DogProducer : IProducer<Dog>
{
    public Dog Produce() => new Dog { Name = "Rex" };
}

// A consumer that handles any Animal — including Dogs
public class AnimalLogger : IConsumer<Animal>
{
    public void Consume(Animal animal)
        => Console.WriteLine($"Logging animal: {animal.Name} says {animal.Sound()}");
}

class Program
{
    static void Main()
    {
        // ── COVARIANCE ───────────────────────────────────────────────
        // DogProducer implements IProducer<Dog>.
        // Because IProducer<T> is covariant (out T), we can assign it to IProducer<Animal>.
        // Dog IS-A Animal, and since we only ever READ T, this is completely safe.
        IProducer<Dog>    dogProducer    = new DogProducer();
        IProducer<Animal> animalProducer = dogProducer;  // covariant assignment — works!

        Animal producedAnimal = animalProducer.Produce();
        Console.WriteLine($"Produced: {producedAnimal.Name} says {producedAnimal.Sound()}");

        // ── CONTRAVARIANCE ───────────────────────────────────────────
        // AnimalLogger implements IConsumer<Animal>.
        // Because IConsumer<T> is contravariant (in T), we can assign it to IConsumer<Dog>.
        // If it can handle any Animal, it can definitely handle a Dog.
        IConsumer<Animal> animalConsumer = new AnimalLogger();
        IConsumer<Dog>    dogConsumer    = animalConsumer;  // contravariant assignment — works!

        dogConsumer.Consume(new Dog { Name = "Buddy" });

        // ── REAL-WORLD COVARIANCE: IEnumerable<T> ───────────────────
        // IEnumerable<T> is declared as IEnumerable<out T> in the BCL.
        // That's why you can assign List<string> to IEnumerable<object>.
        List<string>        dogNames     = new() { "Max", "Bella", "Charlie" };
        IEnumerable<object> objectNames  = dogNames;  // works because IEnumerable is covariant

        Console.WriteLine("\nDog names as objects:");
        foreach (object name in objectNames)
            Console.WriteLine($"  {name}");  // each is a string at runtime, stored as object
    }
}