📝 Lesson 1.2: Generics

The Problem Generics Solve

Imagine writing a simple "box" that holds one value. Without generics, you have two bad options.

Option 1 — a separate class per type. Endless duplication:

class IntBox    { public int Value; }
class StringBox { public string Value; }
class DogBox    { public Dog Value; }
// ...a new class for every type, forever

Option 2 — hold everything as object. One class, but you lose type safety and must cast:

class Box { public object Value; }

Box b = new Box();
b.Value = 42;
int n = (int)b.Value;        // must cast back — and the compiler can't protect you
string s = (string)b.Value;  // compiles, but CRASHES at runtime — it's really an int

Generics give you the best of both: write the box once, use it with any type, and keep the compiler's type checking. That's exactly what List<T> is — one class that safely stores ints, strings, or your own objects.

Generic Classes

You add a type parameter in angle brackets after the class name. By convention it's called T (for "type"):

class Box<T>
{
    public T Value { get; set; }

    public void Show()
    {
        Console.WriteLine($"Box contains: {Value}");
    }
}

Inside the class, T stands in for whatever type the caller chooses. You pick that type when you create an object:

Box<int> intBox = new Box<int>();
intBox.Value = 42;
intBox.Show();               // Box contains: 42

Box<string> textBox = new Box<string>();
textBox.Value = "hello";
textBox.Show();              // Box contains: hello

// intBox.Value = "oops";    // ❌ Compile error — intBox only holds ints

Generic Methods

A single method can be generic too, even in a non-generic class. Put the type parameter after the method name:

void Swap<T>(ref T a, ref T b)
{
    T temp = a;
    a = b;
    b = temp;
}

int x = 1, y = 2;
Swap<int>(ref x, ref y);
Console.WriteLine($"{x}, {y}");   // 2, 1

string first = "A", second = "B";
Swap(ref first, ref second);      // type inferred — no <string> needed
Console.WriteLine($"{first}, {second}");   // B, A

Here's a more practical generic method — printing any array of any type:

void PrintAll<T>(T[] items)
{
    foreach (T item in items)
    {
        Console.WriteLine(item);
    }
}

PrintAll(new int[] { 1, 2, 3 });
PrintAll(new string[] { "a", "b" });

Multiple Type Parameters

A generic type or method can have more than one type parameter, separated by commas. A classic example is a "pair" holding two values of possibly different types:

class Pair<TFirst, TSecond>
{
    public TFirst First { get; set; }
    public TSecond Second { get; set; }
}

Pair<string, int> age = new Pair<string, int>
{
    First = "Ada",
    Second = 30
};

Console.WriteLine($"{age.First} is {age.Second}");   // Ada is 30

Constraints with where

Sometimes a generic method needs to do something with T — compare it, create it, or call a method on it. But if T could be anything, the compiler can't assume those abilities. A constraint restricts what types are allowed, unlocking their capabilities.

This won't compile, because not every type supports >:

T Max<T>(T a, T b)
{
    return a > b ? a : b;   // ❌ Error — C# doesn't know T supports >
}

Add where T : IComparable<T> to promise that T can be compared, then use its CompareTo method:

T Max<T>(T a, T b) where T : IComparable<T>
{
    return a.CompareTo(b) > 0 ? a : b;
}

Console.WriteLine(Max(3, 9));            // 9
Console.WriteLine(Max("apple", "pear")); // pear (alphabetical)

Common constraints you'll encounter:

Generics in .NET

You've been standing on generics the whole time. .NET's collections are generic, which is why they're both flexible and type-safe:

💡 Why it matters: Recognizing the <T> pattern means you can read and use huge parts of .NET confidently. When you see <...>, you're looking at "this type, specialized to work with that type."

Exercise & Quiz

var numbers = new SimpleStack<int>();
numbers.Push(10);
numbers.Push(20);
Console.WriteLine(numbers.Pop());   // 20
Console.WriteLine(numbers.Count);   // 1

class SimpleStack<T>
{
    private List<T> _items = new List<T>();

    // TODO: Push(T item)
    // TODO: T Pop()
    // TODO: int Count { get; }
}

var numbers = new SimpleStack<int>();
numbers.Push(10);
numbers.Push(20);
Console.WriteLine(numbers.Pop());   // 20
Console.WriteLine(numbers.Count);   // 1

var words = new SimpleStack<string>();
words.Push("first");
words.Push("second");
Console.WriteLine(words.Pop());     // second

Console.WriteLine(First(new List<int> { 5, 6, 7 }));   // 5

class SimpleStack<T>
{
    private List<T> _items = new List<T>();

    public int Count => _items.Count;

    public void Push(T item)
    {
        _items.Add(item);
    }

    public T Pop()
    {
        if (_items.Count == 0)
        {
            throw new InvalidOperationException("The stack is empty.");
        }
        T last = _items[_items.Count - 1];
        _items.RemoveAt(_items.Count - 1);
        return last;
    }
}

// Bonus generic method (top-level methods must appear before type declarations)
T First<T>(List<T> items)
{
    if (items.Count == 0)
    {
        throw new InvalidOperationException("The list is empty.");
    }
    return items[0];
}

20
1
second
5

Summary

📚 Additional Resources

• Generics — Microsoft Docs
• Constraints on type parameters
• Generics in .NET — overview

🚀 What's Next?

Generics power all of .NET's collections. In Lesson 1.3: Collections in Depth, you'll go beyond List<T> to dictionaries, sets, queues, and stacks — and learn how to pick the right one for each job.