Generic constraints

// Two ways to write Max without a constraint. The compiler knows nothing about T except that it is an object.
Console.WriteLine(Max(72, 95));
Console.WriteLine(Larger(72, 95));

static T Max<T>(T a, T b) => a > b ? a : b;

static T Larger<T>(T a, T b) => a.CompareTo(b) >= 0 ? a : b;

from session import run

# unconstrained compares two values of an unconstrained T, once with > and once with CompareTo. The build stops.
run("""
cd unconstrained
!dotnet run
""")

$ cd unconstrained
$ dotnet run
unconstrained/Program.cs(5,30): error CS0019: Operator '>' cannot be applied to operands of type 'T' and 'T' [unconstrained/App.csproj]
unconstrained/Program.cs(7,35): error CS7036: There is no argument given that corresponds to the required parameter 'comparisonType' of 'MemoryExtensions.CompareTo(ReadOnlySpan<char>, ReadOnlySpan<char>, StringComparison)' [unconstrained/App.csproj]

The build failed. Fix the build errors and run again.
[exit status 1]

// max.cs: where T : IComparable<T> promises that every T has CompareTo(T), so Max may call it. Any type that keeps the
// promise works, the BCL's own and yours.
Console.WriteLine(Max(72, 95));
Console.WriteLine(Max("Kochi", "Indore"));
Console.WriteLine(Max(12.5m, 9.75m));
Console.WriteLine(Max(new DateOnly(2026, 3, 9), new DateOnly(2026, 3, 2)).ToString("yyyy-MM-dd"));
Console.WriteLine(Max(new Version(10, 0, 401), new Version(9, 0, 304)));
Console.WriteLine(Max(new Grade("B", 70), new Grade("A", 85)));
Console.WriteLine(MaxOf([41, 87, 63, 87, 12]));

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

static T MaxOf<T>(IReadOnlyList<T> items)
    where T : IComparable<T>
{
    if (items.Count == 0)
    {
        throw new ArgumentException("no items to compare", nameof(items));
    }

    T best = items[0];
    for (int i = 1; i < items.Count; i++)
    {
        if (items[i].CompareTo(best) > 0)
        {
            best = items[i];
        }
    }

    return best;
}

// A grade is ordered by its minimum mark.
sealed record Grade(string Letter, int MinimumMark) : IComparable<Grade>
{
    public int CompareTo(Grade? other) => other is null ? 1 : MinimumMark.CompareTo(other.MinimumMark);
}

95
Kochi
12.5
2026-03-09
10.0.401
Grade { Letter = A, MinimumMark = 85 }
87

// repository.cs: practice. Repository<TEntity, TKey> stores entities by their Id. Give TKey the constraints a key
// needs, refuse a second entity with an Id already stored, and look keys up without boxing them.
// Rewrite Repository<TEntity, TKey> at the end of this file until all nine checks pass.
using System.Diagnostics.CodeAnalysis;

(string Check, Func<string> Run, string Expected)[] checks =
[
    ("an int key finds its customer", () => Name(Customers(), 102), "Ravi"),
    ("a missing key finds nothing", () => Name(Customers(), 999), "(none)"),
    ("string keys compare by their text", () => City(Bookings(), string.Concat("PNR", "4522")), "Kochi"),
    ("Guid keys work", () => GuidKeys(), "found"),
    ("a second entity with the same Id is refused", () => Throws(() => Customers().Add(new Customer(101, "Meera"))), "ArgumentException"),
    ("Count counts each Id once", () => CountAfterDuplicate(), "3"),
    ("Remove takes an entity out once", () => RemoveTwice(), "True, False"),
    ("TKey is constrained to IEquatable<TKey>", KeyConstraint, "yes"),
    ("1,000 lookups of an int key allocate nothing", BytesFor1000Lookups, "0 bytes"),
];

int passed = 0;
foreach (var (check, run, expected) in checks)
{
    string got;
    try
    {
        got = run();
    }
    catch (Exception e)
    {
        got = $"throws {e.GetType().Name}";
    }

    bool ok = got == expected;
    if (ok)
    {
        passed++;
    }

    Console.WriteLine(ok ? $"{check}: ok" : $"{check}: FAIL, got {got}, expected {expected}");
}

Console.WriteLine($"{passed} of {checks.Length} checks pass");
return passed == checks.Length ? 0 : 1;

static Repository<Customer, int> Customers()
{
    var customers = new Repository<Customer, int>();
    customers.Add(new Customer(101, "Asha"));
    customers.Add(new Customer(102, "Ravi"));
    customers.Add(new Customer(103, "Imran"));
    return customers;
}

static Repository<Booking, string> Bookings()
{
    var bookings = new Repository<Booking, string>();
    bookings.Add(new Booking("PNR4521", "Pune"));
    bookings.Add(new Booking("PNR4522", "Kochi"));
    return bookings;
}

static string Name(Repository<Customer, int> customers, int id) =>
    customers.TryGet(id, out Customer? customer) ? customer.Name : "(none)";

static string City(Repository<Booking, string> bookings, string pnr) =>
    bookings.TryGet(pnr, out Booking? booking) ? booking.City : "(none)";

static string GuidKeys()
{
    Guid id = Guid.Parse("6f9619ff-8b86-d011-b42d-00c04fc964ff");
    var devices = new Repository<Device, Guid>();
    devices.Add(new Device(id, "scanner"));
    return devices.TryGet(Guid.Parse("6F9619FF-8B86-D011-B42D-00C04FC964FF"), out _) ? "found" : "missing";
}

static string CountAfterDuplicate()
{
    var customers = Customers();
    try
    {
        customers.Add(new Customer(101, "Meera"));
    }
    catch (ArgumentException)
    {
    }

    return $"{customers.Count}";
}

static string RemoveTwice()
{
    var customers = Customers();
    bool first = customers.Remove(102);
    bool second = customers.Remove(102);
    return $"{first}, {second}";
}

static string Throws(Action action)
{
    try
    {
        action();
        return "no exception";
    }
    catch (Exception e)
    {
        return e.GetType().Name;
    }
}

static string KeyConstraint()
{
    Type key = typeof(Repository<,>).GetGenericArguments()[1];
    bool equatable = key.GetGenericParameterConstraints()
        .Any(c => c.IsGenericType && c.GetGenericTypeDefinition() == typeof(IEquatable<>));
    return equatable ? "yes" : "no";
}

static string BytesFor1000Lookups()
{
    var customers = Customers();
    customers.TryGet(101, out _);
    int found = 0;
    long before = GC.GetAllocatedBytesForCurrentThread();
    for (int i = 0; i < 1_000; i++)
    {
        if (customers.TryGet(101 + i % 3, out _))
        {
            found++;
        }
    }

    long bytes = GC.GetAllocatedBytesForCurrentThread() - before;
    return found == 1_000 ? $"{bytes} bytes" : $"found {found} of 1000";
}

interface IEntity<TKey>
{
    TKey Id { get; }
}

sealed record Customer(int Id, string Name) : IEntity<int>;

sealed record Booking(string Id, string City) : IEntity<string>;

sealed record Device(Guid Id, string Kind) : IEntity<Guid>;

// The starter scans a list and compares keys with object.Equals, which boxes an int key at every comparison, and it
// accepts any number of entities with the same Id.
sealed class Repository<TEntity, TKey>
    where TEntity : IEntity<TKey>
{
    private readonly List<TEntity> _items = [];

    public int Count => _items.Count;

    public void Add(TEntity entity) => _items.Add(entity);

    public bool TryGet(TKey id, [MaybeNullWhen(false)] out TEntity entity)
    {
        foreach (TEntity item in _items)
        {
            if (Equals(item.Id, id))
            {
                entity = item;
                return true;
            }
        }

        entity = default;
        return false;
    }

    public bool Remove(TKey id) => _items.RemoveAll(item => Equals(item.Id, id)) > 0;
}

an int key finds its customer: ok
a missing key finds nothing: ok
string keys compare by their text: ok
Guid keys work: ok
a second entity with the same Id is refused: FAIL, got no exception, expected ArgumentException
Count counts each Id once: FAIL, got 4, expected 3
Remove takes an entity out once: ok
TKey is constrained to IEquatable<TKey>: FAIL, got no, expected yes
1,000 lookups of an int key allocate nothing: FAIL, got 95952 bytes, expected 0 bytes
5 of 9 checks pass