Generics in C#

1. Why Generics? Stop Casting Everything

Before generics: ArrayList stored object. Put int in, get object out, cast back. Slow, unsafe. Prerna puts a string by mistake, runtime crash.

// Old way: boxing + runtime crashes
ArrayList list = new ArrayList();
list.Add(5); // int → object = boxing
int x = (int)list[0]; // unbox + cast

// Generics: compile-time safety, no boxing
List<int> list = new List<int>();
list.Add(5); // No boxing
int x = list[0]; // No cast

2. Generic Classes & Methods: <T> Is a Placeholder

T means "Type". Compiler replaces it. Kaushal writes one PizzaBox<T>. Use it for PizzaBox<Margherita> or PizzaBox<Pepperoni>.

public class PizzaBox<T> {
    public T Pizza { get; set; }
}

var vegBox = new PizzaBox<VegPizza>();
vegBox.Pizza = new VegPizza(); // Only VegPizza allowed

3. Constraints: Tell T What It Can Be

Want T to have a method? Add constraint. where T : IPizza means T must implement IPizza.

public class Oven<T> where T : IPizza, new() {
    public T Bake() {
        T pizza = new T(); // new() constraint allows this
        pizza.Cook(); // IPizza constraint allows this
        return pizza;
    }
}

1. Why Do We Need Generics?

Code reuse without losing type safety. Collections, algorithms, DI containers all use generics. Without them, you either duplicate code for each type, or use object and lose compile-time checks. Generics give you both: write once, compiler enforces types.

2. Type Parameters: T, TKey, TValue

Use T for single type. TKey, TValue for dictionaries. Name them meaningfully in public APIs.

public class Cache<TKey, TValue> {
    private Dictionary<TKey, TValue> _store = new();
    public void Add(TKey key, TValue value) => _store[key] = value;
}

Compiler generates specialized version for each T used. List<int> and List<string> are different types at runtime.

3. Constraints: Controlling T

4. Variance: in and out Keywords

out T = covariant. Can return T or subtypes. IEnumerable<out T> means IEnumerable<Pepperoni> is an IEnumerable<Pizza>.

in T = contravariant. Can accept T or supertypes. IComparer<in T> means IComparer<Pizza> can compare Pepperoni.

IEnumerable<string> strings = new List<string>();
IEnumerable<object> objects = strings; // Covariant: OK

Action<object> actObj = o => Console.WriteLine(o);
Action<string> actStr = actObj; // Contravariant: OK

5. Memory: How Generics Work at Runtime

For reference types: CLR creates one shared implementation. List<string> and List<Pizza> share code. For value types: CLR creates specialized version per type. List<int> and List<double> have separate code. That's why List<int> has no boxing. Each int stored directly in array, 4 bytes each. ArrayList boxes each int to heap object, 24 bytes each + reference. 6x memory waste. Kashvee running List<int> with 1M items = 4MB. ArrayList = 24MB+. Plus GC pressure from 1M objects.