📝 Lesson 2.1: Delegates and Lambdas

Methods as Data

You already pass values into methods — numbers, strings, objects. What if you could pass a method itself, so the receiving code can call it? That's exactly what delegates make possible.

Think of a delegate as a "slot" for a method. The slot specifies the shape of method it accepts (say, "takes two ints, returns an int"), and you can plug in any matching method — then swap it out later.

This unlocks a powerful pattern: writing general code that does the structure of a task, while the caller supplies the specific behavior.

Declaring a Delegate

You can declare a delegate type with the delegate keyword. It looks like a method signature with no body:

// A delegate type: "any method taking two ints and returning an int"
delegate int MathOp(int a, int b);

Now any matching method can be stored in a variable of that type and called through it:

int Add(int a, int b) => a + b;
int Multiply(int a, int b) => a * b;

MathOp op = Add;              // plug in the Add method
Console.WriteLine(op(3, 4)); // 7 — calling Add through the delegate

op = Multiply;               // swap in a different method
Console.WriteLine(op(3, 4)); // 12 — now it calls Multiply

Func, Action, and Predicate

In practice you rarely declare your own delegate types, because .NET provides ready-made generic ones that cover almost every case. These are the ones you'll use constantly:

The rule for Func: the last type parameter is the return type; the earlier ones are parameters. So Func<int, int, int> means "takes two ints, returns an int" — our MathOp without the custom declaration:

Func<int, int, int> add = Add;        // two int params, int result
Console.WriteLine(add(3, 4));         // 7

Action<string> greet = name => Console.WriteLine($"Hi, {name}!");
greet("Ada");                         // Hi, Ada!

Predicate<int> isEven = n => n % 2 == 0;
Console.WriteLine(isEven(10));        // True

Lambda Expressions

Writing a whole named method just to plug it into a delegate is often overkill. A lambda expression is a compact, inline, anonymous method. You've already seen the => ("goes to") arrow in expression-bodied methods; lambdas use the same arrow:

// Parameters => result
Func<int, int, int> add = (a, b) => a + b;
Func<int, int> square = x => x * x;
Action greet = () => Console.WriteLine("Hello!");

Console.WriteLine(add(3, 4));   // 7
Console.WriteLine(square(5));   // 25
greet();                        // Hello!

Anatomy of a lambda:

• Parameters in parentheses on the left — (a, b). With exactly one parameter you can drop the parentheses: x => x * x.
• The => arrow.
• The body on the right — a single expression whose value is returned automatically.

For multiple statements, use braces and an explicit return:

Func<int, string> describe = n =>
{
    if (n > 0) return "positive";
    if (n < 0) return "negative";
    return "zero";
};

Console.WriteLine(describe(-5));   // negative

Passing Behavior to Methods

Here's where it all pays off. A method can accept a delegate as a parameter, letting the caller inject custom behavior. Consider a method that processes a list but lets you decide the operation:

// Applies the given operation to every number and prints the result
void ForEachNumber(List<int> numbers, Action<int> action)
{
    foreach (int n in numbers)
    {
        action(n);
    }
}

List<int> nums = new List<int> { 1, 2, 3 };

ForEachNumber(nums, n => Console.WriteLine(n * 10));   // 10, 20, 30
ForEachNumber(nums, n => Console.WriteLine($"[{n}]")); // [1], [2], [3]

Same loop, totally different behavior — chosen by the caller at the call site. Now a filtering example using a Func that returns a bool:

List<int> Filter(List<int> numbers, Func<int, bool> test)
{
    List<int> results = new List<int>();
    foreach (int n in numbers)
    {
        if (test(n))          // the caller decides what "keep" means
        {
            results.Add(n);
        }
    }
    return results;
}

List<int> nums = new List<int> { 1, 2, 3, 4, 5, 6 };

List<int> evens = Filter(nums, n => n % 2 == 0);     // 2, 4, 6
List<int> big = Filter(nums, n => n > 3);            // 4, 5, 6

Capturing Variables

A lambda can use variables from the surrounding code, not just its own parameters. This is called capturing (or a "closure"):

int threshold = 3;

Func<int, bool> aboveThreshold = n => n > threshold;   // captures 'threshold'

Console.WriteLine(aboveThreshold(5));   // True
Console.WriteLine(aboveThreshold(2));   // False

The lambda "remembers" threshold even though it wasn't passed in as a parameter. This makes lambdas great for building behavior tailored to the current context.

int factor = 2;
Func<int, int> scale = n => n * factor;
Console.WriteLine(scale(10));   // 20

factor = 5;                     // change it afterward
Console.WriteLine(scale(10));   // 50 — uses the updated factor

Exercise & Quiz

List<int> nums = new List<int> { 1, 2, 3, 4, 5 };

// TODO: use Transform to double each, then print

List<int> Transform(List<int> numbers, Func<int, int> op)
{
    // TODO: apply op to each element into a new list
    return new List<int>();
}

// TODO: int CountWhere(List<int> numbers, Func<int, bool> test)

List<int> nums = new List<int> { 1, 2, 3, 4, 5 };

List<int> doubled = Transform(nums, n => n * 2);
Console.WriteLine(string.Join(", ", doubled));    // 2, 4, 6, 8, 10

List<int> squared = Transform(nums, n => n * n);
Console.WriteLine(string.Join(", ", squared));    // 1, 4, 9, 16, 25

Console.WriteLine(Transform(nums, n => n + 100)[0]);  // 101

Console.WriteLine(CountWhere(nums, n => n % 2 == 0)); // 2 (evens: 2,4)
Console.WriteLine(CountWhere(nums, n => n > 50));      // 0

List<int> Transform(List<int> numbers, Func<int, int> op)
{
    List<int> results = new List<int>();
    foreach (int n in numbers)
    {
        results.Add(op(n));
    }
    return results;
}

int CountWhere(List<int> numbers, Func<int, bool> test)
{
    int count = 0;
    foreach (int n in numbers)
    {
        if (test(n))
        {
            count++;
        }
    }
    return count;
}

Summary

📚 Additional Resources

• Delegates — C# Programming Guide
• Lambda expressions — reference
• Func<T,TResult> — API reference

🚀 What's Next?

Delegates hold methods — and that's the mechanism behind events, C#'s way of letting objects broadcast notifications. In Lesson 2.2: Events, you'll build objects that others can subscribe to and react to.