Delegates and Events

In simple words#

Learning objectives#

• Declare and call a delegate
• Use the built-in Func and Action delegates
• Pass a method as an argument
• Publish and subscribe to an event

Explanation#

A delegate type describes a method signature: delegate int MathOp(int a, int b);. Any method with that shape can be stored in a MathOp variable and called later.

You rarely declare your own: Func<T1, T2, TResult> covers methods that return a value (the last type is the return type) and Action<T> covers methods that return void.

Passing a method as an argument lets the caller decide part of the behaviour: Apply(10, 5, Subtract).

An event (public event EventHandler<int>? Boiled;) is a delegate with protection: outside code can only += (subscribe) or -= (unsubscribe). Only the owning class can raise it.

Raise an event with Boiled?.Invoke(this, value). The ?. skips the call when nobody has subscribed.

Syntax#

1Func<int, int, int> add = Add;        // two int inputs, int result
2Action<string> log = Console.WriteLine; // string input, no result
3

4public event EventHandler<OrderPlacedArgs>? OrderPlaced;
5OrderPlaced?.Invoke(this, args);       // raise
6service.OrderPlaced += HandleOrder;    // subscribe

Code example: Calculator operations and a kettle event#

1MathOp op = Add;
2Console.WriteLine(op(6, 3));
3op = Multiply;
4Console.WriteLine(op(6, 3));
5Console.WriteLine(Apply(10, 5, Subtract));
6

7Func<string, string> shout = Shout;
8Action<string> log = Console.WriteLine;
9log(shout("saved"));
10

11var kettle = new Kettle();
12kettle.Boiled += SoundAlarm;
13kettle.Boiled += WriteLog;
14kettle.Heat();
15

16static int Add(int a, int b) => a + b;
17static int Multiply(int a, int b) => a * b;
18static int Subtract(int a, int b) => a - b;
19static int Apply(int a, int b, MathOp operation) => operation(a, b);
20static string Shout(string text) => text.ToUpper() + "!";
21

22static void SoundAlarm(object? sender, int temperature) =>
23    Console.WriteLine(
quot;Alarm: water boiled at {temperature} degrees");
24static void WriteLog(object? sender, int temperature) =>
25    Console.WriteLine("Log: kettle switched off");
26

27delegate int MathOp(int a, int b);
28

29class Kettle
30{
31    public event EventHandler<int>? Boiled;
32

33    public void Heat()
34    {
35        for (int t = 90; t <= 100; t += 5)
36        {
37            Console.WriteLine(
quot;Heating... {t}");
38        }
39        Boiled?.Invoke(this, 100);
40    }
41}

9
18
5
SAVED!
Heating... 90
Heating... 95
Heating... 100
Alarm: water boiled at 100 degrees
Log: kettle switched off

This example is illustrative. Copy or download it and run it in your own environment; the expected output is shown above.

Step-by-step explanation#

1. MathOp op = Add stores the Add method in a variable; op(6, 3) calls it.
2. Assigning Multiply to the same variable changes what op does.
3. Apply receives a method as a parameter and calls it — the caller chose Subtract.
4. Func<string, string> and Action<string> are built-in delegate types, so no custom declaration is needed.
5. Two methods subscribe to kettle.Boiled with +=. When Heat raises the event, both run in order.

Real-world use case#

Common mistakes#

Best practices#

• Use Func and Action instead of custom delegate types
• Expose events, not public delegate fields
• Raise events with ?.Invoke
• Use EventHandler<T> for the standard (sender, args) shape

Remember this#

Practice exercise#

1var tags = Transform(["csharp", "dotnet"], AddHash);
2Console.WriteLine(string.Join(" ", tags));   // #csharp #dotnet
3

4static List<string> Transform(List<string> items, Func<string, string> change)
5{
6    var result = new List<string>();
7    foreach (var item in items) result.Add(change(item));
8    return result;
9}
10

11static string AddHash(string word) => "#" + word;

Mini quiz#

Want more? Practise all C# MCQs · C# interview questions

Related topics#

My notes#

Saved in this browser.