Delegates, Events, and Lambda Expressions

# CHAPTER 23

Delegates, Events, and Lambda Expressions #

1. Introduction #

2. Learning Objectives #

• Understand what a Delegate is (a pointer to a function).

• Use the built-in Action and Func delegates.

• Implement publisher-subscriber architecture using event.

• Understand Lambda Expressions deeply.

3. What is a Delegate? #

using System;

class Program
{
    // 1. Define the Delegate signature (Must match the method it will hold)
    public delegate void PrintDelegate(string message);

    static void PrintToConsole(string msg) { Console.WriteLine($"Console: {msg}"); }
    static void PrintToUpper(string msg) { Console.WriteLine($"UPPER: {msg.ToUpper()}"); }

    static void Main()
    {
        // 2. Instantiate the delegate and point it to a method
        PrintDelegate myPrinter = PrintToConsole;
        myPrinter("Hello!"); // Executes PrintToConsole("Hello!")

        // 3. Reassign it!
        myPrinter = PrintToUpper;
        myPrinter("Hello!"); // Executes PrintToUpper("Hello!")
    }
}

4. Action and Func (Modern Delegates) #

• Action<T>: Points to a method that returns void.

• Func<T, TResult>: Points to a method that returns a value (the last parameter is the return type).

// Action (Returns void, takes a string)
Action<string> modernPrinter = PrintToConsole;
modernPrinter("Using Action!");

// Func (Takes an int, returns an int)
Func<int, int> squareNumber = (x) => x * x; // Using a Lambda Expression!
Console.WriteLine(squareNumber(5)); // Prints 25

5. Events (Publisher / Subscriber) #

• Publisher: The class that triggers (fires) the event.

• Subscriber: The classes that listen for the event.

Imagine an alarm system.

// 1. The Publisher
class AlarmClock
{
    // Define the Event
    public event Action OnRing;

    public void TriggerAlarm()
    {
        Console.WriteLine("Clock hits 7:00 AM!");
        // Check if anyone is listening, then FIRE the event!
        if (OnRing != null) 
        {
            OnRing.Invoke(); 
        }
    }
}

// 2. The Subscribers
class Program
{
    static void WakeUpPerson() { Console.WriteLine("Person: Waking up!"); }
    static void TurnOnCoffeeMaker() { Console.WriteLine("Coffee Maker: Brewing coffee..."); }

    static void Main()
    {
        AlarmClock clock = new AlarmClock();

        // Subscribe to the event using +=
        clock.OnRing += WakeUpPerson;
        clock.OnRing += TurnOnCoffeeMaker;

        // Triggering the alarm automatically calls BOTH subscribed methods!
        clock.TriggerAlarm();
    }
}

6. Lambda Expressions #

AlarmClock myClock = new AlarmClock();

// Subscribing with a Lambda instead of creating a whole new method!
myClock.OnRing += () => Console.WriteLine("Lambda: Doing something quick!");

myClock.TriggerAlarm();

7. Common Mistakes #

• Using = instead of += for Events: If you write clock.OnRing = WakeUpPerson;, you completely erase all previous subscribers! Always use += to subscribe and -= to unsubscribe.

• Memory Leaks with Events: If an object subscribes to a static event but forgets to unsubscribe (-=) before being destroyed, the event will keep the object alive in memory permanently.

8. Best Practices #

• Never fire an event without checking if it is null first (e.g., OnRing?.Invoke();). If an event has no subscribers, calling .Invoke() will throw a NullReferenceException.

9. Exercises #

1. 1. Create a delegate MathOp that takes two ints and returns an int. Point it to an Add method, then reassign it to a Multiply method.

1. 2. Rewrite exercise 1 using the built-in Func<int, int, int> delegate.

10. MCQs with Answers #

11. Interview Questions #

• Q: Explain the difference between Action, Func, and Predicate.

• Q: What is the Publisher/Subscriber pattern, and how do C# Events facilitate it?

12. Summary #

13. Next Chapter Recommendation #