How do generic methods work in C#? Explain how the compiler infers type arguments, when inference fails, and when you would make a method generic instead of the whole class.

1. The inference algorithm in more detail

The C# specification's algorithm:

• Exact, lower-bound and upper-bound inferences: for parameter type IEnumerable<T> and argument List<string>, the compiler finds IEnumerable<string> via the interface and infers a lower bound T :> string (thanks to covariance, IEnumerable<object> would also accept it).
• Fixing: each type variable is fixed to a type from its bound set such that every bound is satisfied, choosing the "best" one.
• Dependent type parameters: for Select<TSource, TResult>(IEnumerable<TSource>, Func<TSource, TResult>), TSource is fixed first from the source; then the lambda is bound with TSource known, and its body's type gives TResult.

C# 10 improved inference for lambdas with natural types and C# 12/13 refined collection expression and params span inference, but the core remains argument-based.

2. Generic methods and code generation

Each distinct instantiation of a generic method with value-type arguments gets its own JIT-compiled code; reference-type instantiations share code with a generic dictionary parameter. Generic virtual methods (virtual T Get<T>()) are more expensive to dispatch: the runtime must find the instantiation per call (via a lookup), which is slower than a normal virtual call — avoid them on hot paths.

3. Constraints on method type parameters

Constraints are part of the method's contract but not part of the signature for overloading: you can't overload M<T>(T x) where T : class with M<T>(T x) where T : struct (same signature). Overload resolution ignores constraints when choosing candidates, then reports an error if the chosen one's constraints aren't satisfied — a source of confusing errors. (C# 7.3 improved this: candidates with unsatisfied constraints are removed in more cases.)

4. Explicit type arguments and partial inference

C# doesn't support partial type argument inference: if a method has two type parameters and you want to specify one, you must specify both (Map<Order, OrderDto>(order)). A workaround is splitting into two calls (Map(order).To<OrderDto>()) where the first infers and the second is explicit.

5. Generic extension methods

Most LINQ is generic extension methods over IEnumerable<T>. Constraint design affects discoverability: public static T Clamp<T>(this T value, T min, T max) where T : IComparable<T> appears on every comparable type in IntelliSense — keep such extensions in specific namespaces.

Try it yourself

1. Call Max(3, 4.5) with a generic Max<T> and inspect the inferred type in the IDE.
2. Write T Create<T>() and try calling it without type arguments.
3. Write TResult Apply<T, TResult>(T value, Func<T, TResult> f) and call it with a lambda; then with a method group that has overloads.
4. Refactor a per-type generic service interface into a single interface with a generic method.

namespace Generics.Methods;

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

    public static T Clamp<T>(T value, T min, T max) where T : IComparable<T>
        => value.CompareTo(min) < 0 ? min : value.CompareTo(max) > 0 ? max : value;

    public static TResult[] MapAll<TSource, TResult>(IReadOnlyList<TSource> source, Func<TSource, TResult> map)
    {
        var result = new TResult[source.Count];
        for (var i = 0; i < source.Count; i++)
        {
            result[i] = map(source[i]);
        }
        return result;
    }
}

public sealed class RetryPolicy(int maxAttempts)
{
    public async Task<T> ExecuteAsync<T>(Func<CancellationToken, Task<T>> action, CancellationToken ct)
    {
        for (var attempt = 1; ; attempt++)
        {
            try
            {
                return await action(ct);
            }
            catch (HttpRequestException) when (attempt < maxAttempts)
            {
                await Task.Delay(TimeSpan.FromMilliseconds(200 * attempt), ct);
            }
        }
    }
}

public static class Program
{
    public static async Task Main()
    {
        Console.WriteLine(Algorithms.Max(3, 7));          // T = int
        Console.WriteLine(Algorithms.Max(3, 7L));         // T = long
        Console.WriteLine(Algorithms.Clamp(new DateOnly(2030, 1, 1), DateOnly.MinValue, new DateOnly(2026, 12, 31)));

        string[] lengths = Algorithms.MapAll([1, 22, 333], n => n.ToString()); // TSource = int, TResult = string
        Console.WriteLine(string.Join(",", lengths));

        var retry = new RetryPolicy(maxAttempts: 3);
        var answer = await retry.ExecuteAsync(_ => Task.FromResult(42), CancellationToken.None); // T = int inferred
        Console.WriteLine(answer);
    }
}