Generics and constraints

Without generics, a reusable method either repeats itself per type or falls back to object and loses the type on the way out.

public static object First(object[] items) => items[0];   // loses the type

A type parameter keeps the connection between what went in and what comes out:

public static T First<T>(List<T> items) => items[0];

int n = First(new List<int> { 1, 2, 3 });       // T inferred as int
string s = First(new List<string> { "a", "b" }); // T inferred as string

T is a placeholder the caller fills, almost always without writing it out — the compiler infers it from the argument.

Try it

Constraints

Inside the method, you may only do what every possible T allows — by default, almost nothing. where narrows what a caller may pass, and in exchange lets the method use it:

public static T Max<T>(T a, T b) where T : IComparable<T>
    => a.CompareTo(b) >= 0 ? a : b;

where T : IComparable<T> says: only types that know how to compare themselves to another instance of themselves may be used here. Without the constraint, a.CompareTo(b) would not compile — the compiler has no way to know an arbitrary T supports it.

Common constraints: where T : class (reference types only), where T : struct (value types only), where T : new() (must have a public parameterless constructor, so the method can create one), and where T : SomeBaseType (must derive from it, or implement it if it is an interface).

Generic classes work the same way

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

var intBox = new Box<int> { Value = 5 };
var stringBox = new Box<string> { Value = "hi" };

List<T> and Dictionary<TKey, TValue> are themselves ordinary generic classes, written with exactly this feature — nothing about them is special-cased into the language.