How does type inference work in C#? When should you use var, target-typed new and inferred lambda types, and when does explicit typing read better?

1. var is compile-time only

var total = 10m;

compiles to exactly the same IL as decimal total = 10m; — the local slot is typed [System.Runtime]System.Decimal. There is no runtime cost, no reflection, no late binding. Contrast with dynamic, which compiles to object plus DLR call sites.

Because the type is decided once, inference can lock in a narrower type than you intended:

var items = new List<Order>();   // List<Order>, not IList<Order>
var x = 5;                       // int - later x = 5_000_000_000 won't compile
var shape = new Circle();        // Circle - cannot later assign a Square

2. How generic method type inference works

For Max(3, 7.5), the compiler runs a two-phase algorithm from the specification:

1. Phase 1: for each argument, infer bounds for type parameters from the argument type (int and double become candidate bounds for T).
2. Phase 2: fix each type parameter to the best type among its bounds that all others convert to — here double, since int converts implicitly to double.

If no single best type exists (e.g. Max("a", 5)), inference fails with CS0411 and you must specify Max<object>(...).

Lambdas participate in phases: input types are inferred first from other arguments, then the lambda body is bound to infer output types. That is why Select(o => o.Total) works: TSource is known from the source, then TResult is inferred from the lambda body.

Inference never uses the return type or the variable being assigned to: T Create<T>() cannot be called as Order o = Create();.

3. Natural types for lambdas and method groups (C# 10)

var parse = (string s) => int.Parse(s);     // Func<string, int>
var log = Console.WriteLine;                // error: ambiguous overloads
var now = DateTime.UtcNow.ToString;         // Func<string> if unambiguous
var maybe = string? (bool b) => b ? "y" : null;  // explicit return type

The compiler picks Func<...>/Action<...> when they fit, or synthesises an internal delegate type when they don't (e.g. ref parameters). This also made minimal APIs possible: app.MapGet("/orders/{id}", (int id, IOrderService svc) => ...) infers a delegate with full parameter metadata for binding.

C# 12 added default parameter values in lambdas, and C# 14 allows parameter modifiers (ref, out, scoped) without explicit types.

4. Best common type for arrays and conditionals

• new[] { 1, 2, 3 } → int[]; new[] { 1, 2.5 } → double[]; new[] { "a", 1 } → error (no best type; object is not chosen automatically).
• flag ? new Circle() : new Square() — before C# 9 an error; with target typing, Shape s = flag ? new Circle() : new Square(); works because the target type is known.
• Collection expressions ([1, 2, 3]) have no natural type — var x = [1, 2, 3]; does not compile, by design, because the right collection type depends on the target.

5. var and nullable reference types

With NRT enabled, var locals are declared as nullable (string?), deliberately. The idea: the variable's declared type allows null, but the flow state after var s = "hello"; is not-null, so no warnings. This avoids spurious warnings when a variable is later assigned a maybe-null value. It means var can never be used to force non-nullability.

6. Readability research and guidance

Microsoft's .NET runtime coding guidelines use var only when the type is explicitly named on the right side (new, explicit cast) — the runtime team optimises for reviewers reading diffs without IDE support. Many application teams use var more widely, relying on IDE inlay hints. Both are defensible; the senior point is to pick a rule, encode it in .editorconfig, and apply it consistently, with exceptions for numerics, interfaces, and async results.

Try it yourself

1. Hover over var in var q = db.Orders.Where(...) and then add .AsEnumerable() — see how the inferred type changes and what that means for SQL translation.
2. Write var price = 9.99; and pass it to a method taking decimal.
3. Try var nums = [1, 2, 3]; and read the error.
4. Configure the .editorconfig rules above with :warning and build.

namespace Types;

public sealed record Order(int Id, decimal Total);

public static class Inference
{
    // Fields cannot use var; target-typed new keeps them short
    private static readonly Dictionary<string, List<Order>> ByCustomer = new();

    public static void Main()
    {
        var orders = new List<Order> { new(1, 120m), new(2, 40m) };   // obvious type
        int[] ids = [1, 2, 3];                                         // collection expression needs a target
        decimal threshold = 100m;                                      // explicit for money

        // Generic inference: TResult = decimal
        var totals = orders.Select(o => o.Total);

        // Anonymous type requires var
        var summary = new { Count = orders.Count, Sum = orders.Sum(o => o.Total) };
        Console.WriteLine(summary);                                    // { Count = 2, Sum = 160 }

        // Natural lambda type (C# 10)
        var isBig = (Order o) => o.Total > threshold;                  // Func<Order, bool>
        Console.WriteLine(orders.Count(isBig));

        // Literal trap
        var price = 9.99;                                              // double!
        Console.WriteLine(price.GetType().Name);                       // Double

        Console.WriteLine($"{ids.Length} {totals.Sum()} {ByCustomer.Count}");
    }

    // Keep EF Core queries as IQueryable<T> so filters run in SQL
    public static IQueryable<Order> BigOrders(IQueryable<Order> source, decimal min)
        => source.Where(o => o.Total >= min);
}