C# Lambda Expressions: Syntax, Func and Action, Closures and LINQ

A lambda expression is a small anonymous function written inline with the => operator ("goes to"). The parameters go on the left, the result on the right:

using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
    static void Main()
    {
        Func<decimal, decimal> addVat = price => price * 1.2m;
        Func<int, int, int> max = (a, b) => a > b ? a : b;
        Action<string> shout = text => Console.WriteLine(text.ToUpper() + "!");

        Console.WriteLine(addVat(50m));
        Console.WriteLine(max(7, 12));
        shout("order shipped");

        var prices = new List<decimal> { 12.5m, 80m, 5m, 150m };
        var expensive = prices.Where(p => p > 50m).Select(p => addVat(p));
        Console.WriteLine(string.Join(", ", expensive));
    }
}

Output:

60.0
12
ORDER SHIPPED!
96.0, 180.0

A lambda has no type of its own. It becomes a delegate (an object that points to a function) of whatever delegate type the context expects: Func<decimal, decimal> here, a Predicate<T> for List.FindAll, an EventHandler for an event. Func delegates return a value and Action delegates do not; the Func and Action page lists the full family.

Syntax Forms

x => x * x                         // one parameter: parentheses optional
(x, y) => x + y                    // several parameters
() => DateTime.Now.Year            // no parameters
(int x, string s) => s.Length > x  // explicit parameter types
order =>                           // statement lambda: a block with return
{
    decimal subtotal = order.Qty * order.Price;
    return subtotal > 100m ? subtotal * 0.9m : subtotal;
}

An expression lambda has a single expression after =>, and its value is the result. A statement lambda has a block in braces, which can contain any statements and must return a value on every path if the delegate returns one (otherwise CS1643, Not all code paths return a value in lambda expression).

Newer versions added more forms, all optional:

• C# 9: discard parameters, so several unused parameters can all be _ ((_, _) => Save()), and static lambdas that are forbidden from capturing variables.
• C# 10: a "natural type", so var square = (int x) => x * x; infers Func<int, int>. Before that, var f = x => x * 2; fails; even in C# 10 it still fails without a parameter type, with CS8917 The delegate type could not be inferred.
• C# 12: default parameter values, (int x, int y = 1) => x + y.

Passing Lambdas to Methods

Any method that takes a delegate parameter accepts a lambda. That is how you pass behavior, not just data:

using System;
using System.Collections.Generic;

class Program
{
    static List<string> Filter(List<string> items, Func<string, bool> keep)
    {
        var result = new List<string>();
        foreach (string item in items)
        {
            if (keep(item)) result.Add(item);
        }
        return result;
    }

    static void Main()
    {
        var files = new List<string> { "report.pdf", "photo.jpg", "cv.txt", "scan.pdf" };

        var pdfs = Filter(files, f => f.EndsWith(".pdf"));
        var shortNames = Filter(files, f => f.Length <= 9);

        Console.WriteLine(string.Join(", ", pdfs));
        Console.WriteLine(string.Join(", ", shortNames));

        files.Sort((a, b) => a.Length.CompareTo(b.Length));
        Console.WriteLine(string.Join(", ", files));
    }
}

Output:

report.pdf, scan.pdf
photo.jpg, cv.txt, scan.pdf
cv.txt, scan.pdf, photo.jpg, report.pdf

Filter does not know what "keep" means; the caller decides with a lambda. List.Sort works the same way: the lambda is a comparison that returns negative, zero or positive, and Sort calls it as often as it needs to.

Lambdas in LINQ

LINQ is the place most C# code meets lambdas. Every query operator takes one: Where a condition, Select a projection, OrderBy a key, Sum a value to add up:

using System;
using System.Linq;

class Order
{
    public string Customer;
    public int Qty;
    public decimal Price;
}

class Program
{
    static void Main()
    {
        Order[] orders =
        {
            new Order { Customer = "Ana", Qty = 2, Price = 30m },
            new Order { Customer = "Ben", Qty = 1, Price = 250m },
            new Order { Customer = "Ana", Qty = 5, Price = 4m },
            new Order { Customer = "Cy",  Qty = 3, Price = 15m },
        };

        var bigOrders = orders
            .Where(o => o.Qty * o.Price >= 45m)
            .OrderByDescending(o => o.Qty * o.Price)
            .Select(o => $"{o.Customer}: {o.Qty * o.Price}");

        foreach (string line in bigOrders) Console.WriteLine(line);

        var perCustomer = orders
            .GroupBy(o => o.Customer)
            .Select(g => new { Name = g.Key, Total = g.Sum(o => o.Qty * o.Price) });

        foreach (var c in perCustomer) Console.WriteLine($"{c.Name} spent {c.Total}");
    }
}

Output:

Ben: 250
Ana: 60
Cy: 45
Ana spent 80
Ben spent 250
Cy spent 45

The lambdas do not run where they are written. LINQ stores them and calls them when the query is enumerated by foreach, ToList() or Sum(), which is called deferred execution. The LINQ page covers the operators themselves.

Closures: Captured Variables

A lambda can use local variables and parameters of the method it is written in. It captures the variable, not its current value, and the variable lives on as long as the lambda does:

using System;

class Program
{
    static Func<int> MakeCounter()
    {
        int count = 0;
        return () => ++count;      // count outlives MakeCounter
    }

    static void Main()
    {
        Func<int> next = MakeCounter();
        Console.WriteLine(next());
        Console.WriteLine(next());
        Console.WriteLine(next());

        Func<int> other = MakeCounter();
        Console.WriteLine(other());

        decimal rate = 0.1m;
        Func<decimal, decimal> discount = price => price * rate;
        rate = 0.5m;                       // changed after the lambda was created
        Console.WriteLine(discount(100m)); // uses the current value
    }
}

Output:

1
2
3
1
50.0

Each call to MakeCounter creates a new count, so the two counters are independent. The discount lambda read rate when it ran, not when it was written, so it applied 50%. The compiler implements this by moving captured variables into a hidden class that the method and the lambda share.

The Loop Capture Gotcha

Capturing a loop variable is where closures bite. A for loop has one variable for the entire loop, so every lambda created in it shares that variable:

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        var actions = new List<Action>();
        for (int i = 0; i < 3; i++)
        {
            actions.Add(() => Console.Write($"{i} "));
        }
        foreach (Action a in actions) a();
        Console.WriteLine("<- for loop, shared i");

        actions.Clear();
        for (int i = 0; i < 3; i++)
        {
            int copy = i;                       // a new variable each iteration
            actions.Add(() => Console.Write($"{copy} "));
        }
        foreach (Action a in actions) a();
        Console.WriteLine("<- for loop, copied");

        actions.Clear();
        foreach (int n in new[] { 0, 1, 2 })
        {
            actions.Add(() => Console.Write($"{n} "));
        }
        foreach (Action a in actions) a();
        Console.WriteLine("<- foreach");
    }
}

Output:

3 3 3 <- for loop, shared i
0 1 2 <- for loop, copied
0 1 2 <- foreach

All three lambdas in the first loop ran after the loop had finished, when i was 3. Copying i into a variable declared inside the body gives each lambda its own. foreach gets this right by itself: since C# 5, its iteration variable is a new variable on every pass. Before C# 5 it had the same bug, which is why older answers online still recommend the copy for foreach too.

The same trap applies to anything that runs later: event handlers, timers, Task.Run, and LINQ queries built in a loop and enumerated after it.

Lambdas, Anonymous Methods and Local Functions

Lambdas replaced the C# 2 anonymous method syntax, which still compiles:

Func<int, bool> isEven = delegate (int n) { return n % 2 == 0; };   // C# 2 anonymous method
Func<int, bool> isEven2 = n => n % 2 == 0;                          // lambda

For a helper used only inside one method, C# 7.0 also offers local functions, which have a name, can be recursive and do not allocate a delegate unless you convert them to one. Use a lambda when you are passing behavior to something (LINQ, Sort, an event); use a local function or a private method when you are calling it yourself.

One more distinction appears with LINQ providers such as Entity Framework: a lambda assigned to Expression<Func<T, bool>> is not compiled to code at all but to a data structure describing the code, which the provider translates to SQL. The syntax is identical; the parameter type of the method you call decides which one you get.