Introducing Generics

You have written List<Order> and Dictionary<string, Product> for several lessons. The part in angle brackets is a type parameter: you are telling one general-purpose collection what kind of item it will hold, and the compiler then treats it as a collection of exactly that.

The clearest way to see what this buys is to look at how collections worked before it existed, because the problems it solved are still easy to recreate by accident.

using System.Collections;

// ArrayList holds object, which means it holds anything.
ArrayList orders = new ArrayList();

orders.Add(new Order("SO-4471"));
orders.Add(new Order("SO-4472"));
orders.Add("SO-4473");             // a string, not an Order — compiles happily

foreach (object item in orders)
{
    Order order = (Order)item;     // InvalidCastException on the third item
    Console.WriteLine(order.Reference);
}

• ArrayList stores items as object, the type every other type derives from. Anything at all can go in.
• The third Add is a mistake, and nothing reports it. The compiler cannot object, because a string genuinely is an object.
• Getting an item out requires a cast — the (Order) in brackets — because the collection only knows it holds objects.
• That cast is where the mistake finally surfaces, as an InvalidCastException at run time. The error appears in the loop that reads the data, which may be in a different file, written by a different person, months after the line that put the wrong thing in.
• Change ArrayList to List<Order> and the bad Add stops compiling. The error moves from run time to build time, and from the reader to the writer.

decimal amount = 1_450.00m;

object boxed = amount;              // boxing: the value is copied into an object on the heap
decimal back = (decimal)boxed;      // unboxing: copied back out again

// In an old-style collection, this happens to every single item.
ArrayList amounts = new ArrayList();

for (int i = 0; i < 100_000; i++)
{
    amounts.Add(1_450.00m);         // 100,000 separate heap allocations
}

// With a generic list, the decimals are stored as decimals.
List<decimal> betterAmounts = new List<decimal>();

for (int i = 0; i < 100_000; i++)
{
    betterAmounts.Add(1_450.00m);   // no boxing, one array of decimals
}

• A value type such as int, decimal or bool normally lives directly where it is declared. Storing one in an object variable cannot work that way, so the runtime wraps it in a small object on the heap and copies the value in. That wrapping is boxing.
• Every box is an allocation, and every allocation is eventually work for the garbage collector. Reading the value back means an unboxing cast and another copy.
• List<decimal> has no need for any of this. Its internal array is an array of decimal, so values are stored directly.
• For a handful of items none of this is measurable. For a hundred thousand in a loop it is the difference between noticeable and unnoticeable, and it was one of the main reasons generics were added to the language.

public class Repository<T> where T : class
{
    private readonly List<T> _items = new List<T>();

    public int Count => _items.Count;

    public void Add(T item)
    {
        if (item is null)
        {
            throw new ArgumentNullException(nameof(item));
        }

        _items.Add(item);
    }

    public IReadOnlyList<T> All() => _items;
}

Repository<Order> orders = new Repository<Order>();
orders.Add(new Order("SO-4471"));

Repository<Product> products = new Repository<Product>();
products.Add(new Product("Desk lamp", 1_450m, 12));

// orders.Add(new Product(...));   // does not compile, which is the point

• The T in Repository<T> is a placeholder for a type that the caller chooses. T is a convention, not a keyword; a longer name such as TEntity reads better on types with several parameters.
• Inside the class, T is used exactly like any other type — as a field type, a parameter type, a return type.
• where T : class is a constraint. It restricts what callers may supply, here to reference types, and in exchange lets you rely on that inside the class. Other constraints include where T : IComparable<T> to require a member, and where T : new() to require a parameterless constructor.
• One class definition, and Repository<Order> and Repository<Product> are two distinct types as far as the compiler is concerned. Neither will accept the other's items.