Generics in Depth

You have used generics since the first time you wrote List<string>. A type parameter is a placeholder: List<T> is written once, and the T is filled in when you use it. List<string> holds strings, List<Order> holds orders, and the compiler checks both.

Writing your own generic type is the same idea from the other side. You write the placeholder and let callers choose.

The reason to do it is repetition you cannot remove any other way. A cache for orders and a cache for customers are the same code with one type swapped. Without generics you copy the class, or you store object and cast everything back — losing compile-time checking and paying for boxing on value types.

public class TimedCache<TKey, TValue>
    where TKey : notnull
{
    private readonly Dictionary<TKey, (TValue Value, DateTimeOffset Expires)> _entries = new();
    private readonly TimeSpan _lifetime;

    public TimedCache(TimeSpan lifetime) => _lifetime = lifetime;

    public bool TryGet(TKey key, out TValue? value)
    {
        if (_entries.TryGetValue(key, out var entry) && entry.Expires > DateTimeOffset.UtcNow)
        {
            value = entry.Value;
            return true;
        }

        _entries.Remove(key);
        value = default;
        return false;
    }

    public void Set(TKey key, TValue value) =>
        _entries[key] = (value, DateTimeOffset.UtcNow.Add(_lifetime));
}

// Two very different caches, one class.
TimedCache<string, decimal> rates = new(TimeSpan.FromMinutes(5));
TimedCache<int, Order> orders = new(TimeSpan.FromSeconds(30));

rates.Set("GBP", 1.0m);

if (orders.TryGet(4471, out Order? order))
{
    Console.WriteLine(order!.Reference);
}

• Two type parameters. TKey and TValue are named for their roles; the bare T is a fine name when there is only one and its role is obvious.
• where TKey : notnull is a constraint. It says a key may not be a nullable type, which is what a dictionary key requires. Without it the compiler warns as soon as TKey is used as a Dictionary key.
• TValue has no constraint at all, and look at what the class does with it: stores it, returns it, assigns default to it. That is the complete list of things you can do with an unconstrained type parameter.
• value = default gives you null for a reference type and a zero-filled value for a struct. It is the only way to produce an empty TValue when you know nothing about the type.
• At the two usage sites, TValue is decimal in one case and Order in the other. The decimal version stores decimals directly — no boxing, no cast, which is what an object-based cache could not do.
• TryGet follows the shape of Dictionary.TryGetValue on purpose. Matching the conventions of the framework makes a generic type feel familiar rather than novel.

public static class Selecting
{
    // IComparable<TKey> is what makes CompareTo legal below.
    public static T? HighestBy<T, TKey>(IEnumerable<T> items, Func<T, TKey> keySelector)
        where T : class
        where TKey : IComparable<TKey>
    {
        T? best = null;
        TKey? bestKey = default;

        foreach (T item in items)
        {
            TKey key = keySelector(item);

            if (best is null || key.CompareTo(bestKey!) > 0)
            {
                best = item;
                bestKey = key;
            }
        }

        return best;
    }

    // new() is what makes "new TReport()" legal below.
    public static TReport StartReport<TReport>(string title)
        where TReport : ReportBase, new()
    {
        TReport report = new();
        report.Title = title;        // Allowed because of the ReportBase constraint.
        report.StartedAt = DateTimeOffset.UtcNow;

        return report;
    }
}

// Type arguments are inferred from the arguments you pass.
Order? biggest = Selecting.HighestBy(orders, o => o.Total);
Order? latest = Selecting.HighestBy(orders, o => o.PlacedAt);

// Inference cannot work here, because nothing in the call mentions the type.
VatReport report = Selecting.StartReport<VatReport>("Q3 VAT");

• HighestBy has two type parameters: the item type and the key type. Each carries its own where clause, written on separate lines by convention.
• where TKey : IComparable<TKey> is doing the real work. Remove it and key.CompareTo stops compiling, because nothing says an arbitrary TKey can be compared.
• where T : class allows best to be declared as T? and initialised to null. Without it, the compiler cannot accept null as a value of T, since T might be a struct.
• The second method combines two constraints. ReportBase grants access to Title and StartedAt; new() permits new TReport(). Both are needed, and new() must come last in the list.
• The two HighestBy calls never mention a type argument. The compiler infers T from the collection and TKey from the lambda's return type — decimal in the first call, DateTimeOffset in the second.
• StartReport has to be called with an explicit type argument, because there is nothing in its parameters to infer from. Inference works from arguments only, never from what you assign the result to.
• In real code you would reach for LINQ's MaxBy rather than writing HighestBy. It is shown here because its signature is a compact example of two cooperating constraints, and reading generic signatures is most of the skill.