Generics

The problem: the same code for every type

Suppose you write a method to find the largest number in an array of int. Then you need it for double. Then for decimal, string, DateTime… Copying the method for each type is clearly wrong. Using object for everything loses type safety:

object Largest(object[] items) { ... }
 
var result = Largest(new object[] { 3, 9, 2 });
int x = (int)result;            // cast needed — and it crashes if you guessed the type wrong

Generics let you write the code once, with a type parameter, and use it with any type — while the compiler still checks everything.

You already use generics

List<string> names = new();
Dictionary<string, int> ages = new();
Task<int> pending = ...;

List<T> is defined once, with a placeholder T. List<string> fills in T = string: its Add method only accepts strings, and reading gives you strings — no casts.

Generic methods

Put the type parameter in angle brackets after the method name:

T First<T>(T[] items) => items[0];
 
void PrintTwice<T>(T value)
{
    Console.WriteLine(value);
    Console.WriteLine(value);
}
 
string s = First(new[] { "a", "b" });   // T inferred as string
int n = First<int>(new[] { 1, 2 });     // or given explicitly

The compiler usually infers T from the arguments.

Generic classes

class Box<T>
{
    public T Value { get; }
    public Box(T value) => Value = value;
 
    public Box<TResult> Map<TResult>(Func<T, TResult> transform) => new(transform(Value));
}
 
var number = new Box<int>(21);
var doubled = number.Map(x => x * 2);          // Box<int>
var text = number.Map(x => $"#{x}");           // Box<string>

Use several parameters when needed — Dictionary<TKey, TValue>, Pair<TFirst, TSecond>. By convention, type parameters start with T.

Constraints

Inside a generic method, T could be anything, so you can only use what every type has (the members of object). To use more, add a constraint:

T Largest<T>(T[] items) where T : IComparable<T>
{
    T best = items[0];
    foreach (T item in items)
        if (item.CompareTo(best) > 0) best = item;   // CompareTo is available thanks to the constraint
    return best;
}
 
Largest(new[] { 3, 9, 2 });           // 9
Largest(new[] { "pear", "zebra" });   // "zebra"

default(T)

What's an "empty" value for an unknown type? default — 0 for numbers, false for bool, null for reference types:

T FirstOrDefault<T>(List<T> items) => items.Count > 0 ? items[0] : default!;

Why generics matter

• Type safety — mistakes are caught at compile time, not with a crash.
• No casts — code is cleaner.
• Performance — List<int> stores real ints; a list of object would box every number into a separate heap object.

Try it

Key takeaways

• Generics let one class or method work with many types, safely.
• Type parameters (T) are filled in by type arguments (List<int>) or inferred by the compiler.
• Constraints (where T : ...) unlock members you can use on T.
• Prefer generics over object: type safety, no casts, no boxing.