📝 Lesson 2.2: Events

The Publisher/Subscriber Idea

An event is a message an object sends when something notable happens. The object that raises the event is the publisher; objects that want to react are subscribers. The publisher doesn't know or care who is listening — it just broadcasts.

Think of a newsletter. The publisher sends out an issue; every subscriber receives it. New readers can subscribe and existing ones can unsubscribe at any time, and the publisher never needs a hard-coded list of names.

Events build directly on the delegates from Lesson 2.1 — an event is essentially a carefully-guarded delegate that holds a list of subscriber methods to call.

A First Event

Let's build an alarm clock that announces when it rings. The publisher declares an event and raises it at the right moment:

class AlarmClock
{
    // Declare an event based on the Action delegate (no data payload)
    public event Action Rang;

    public void Tick()
    {
        Console.WriteLine("Tick...");
        // Raise the event — notify all subscribers (if any)
        Rang?.Invoke();
    }
}

Now some subscribers react when the alarm rings:

AlarmClock clock = new AlarmClock();

// Subscribe: add methods to be called when Rang is raised
clock.Rang += () => Console.WriteLine("😴 Wake up!");
clock.Rang += () => Console.WriteLine("☕ Starting the coffee machine.");

clock.Tick();   // raises Rang → both subscribers run

Tick...
😴 Wake up!
☕ Starting the coffee machine.

Subscribing and Unsubscribing

You subscribe with += and unsubscribe with -=. Multiple subscribers can attach, and they're all invoked in order when the event is raised (this is a multicast delegate under the hood).

void MorningRoutine() => Console.WriteLine("Getting up.");

clock.Rang += MorningRoutine;   // subscribe a named method
clock.Tick();                   // MorningRoutine runs

clock.Rang -= MorningRoutine;   // unsubscribe
clock.Tick();                   // MorningRoutine no longer runs

The Standard EventHandler Pattern

Using Action works, but .NET has a widely-followed convention for events that all its own APIs use. Following it makes your code familiar to every C# developer. The convention uses the built-in EventHandler delegate, whose subscribers take two parameters:

• object sender — the object that raised the event.
• EventArgs e — data about the event (or EventArgs.Empty if none).

class AlarmClock
{
    public event EventHandler Rang;   // the standard event delegate

    public void Tick()
    {
        Console.WriteLine("Tick...");
        Rang?.Invoke(this, EventArgs.Empty);   // 'this' is the sender
    }
}

AlarmClock clock = new AlarmClock();

clock.Rang += (sender, e) => Console.WriteLine("Wake up!");
clock.Tick();

Passing Data with EventArgs

Often subscribers need details about what happened. You provide them by creating a class that derives from EventArgs (inheritance from the intro course, again) and using the generic EventHandler<T>:

// 1) Define a data payload
class TemperatureChangedEventArgs : EventArgs
{
    public double NewTemperature { get; }

    public TemperatureChangedEventArgs(double newTemperature)
    {
        NewTemperature = newTemperature;
    }
}

// 2) Publisher raises the event with data
class Thermostat
{
    public event EventHandler<TemperatureChangedEventArgs> TemperatureChanged;

    private double _temperature;
    public double Temperature
    {
        get => _temperature;
        set
        {
            _temperature = value;
            TemperatureChanged?.Invoke(this, new TemperatureChangedEventArgs(value));
        }
    }
}

Thermostat thermostat = new Thermostat();

thermostat.TemperatureChanged += (sender, e) =>
{
    Console.WriteLine($"Temperature is now {e.NewTemperature}°C");
    if (e.NewTemperature > 30)
    {
        Console.WriteLine("⚠️ It's getting hot!");
    }
};

thermostat.Temperature = 22;   // raises the event
thermostat.Temperature = 35;   // raises again → warning fires

Temperature is now 22°C
Temperature is now 35°C
⚠️ It's getting hot!

The subscriber reads e.NewTemperature to get the detail it needs. Setting the property is all it takes to notify everyone listening.

Why Events, Not Plain Delegates?

An event is a delegate with guardrails. If you exposed a public delegate field instead, any outside code could misuse it:

💡 The point of event: It lets outsiders subscribe and unsubscribe, but only the publishing class can raise the event or clear its subscribers. That encapsulation (a theme from the intro's OOP) prevents a whole category of bugs — subscribers can't accidentally trigger or wipe each other.

Exercise & Quiz

BankAccount account = new BankAccount();

// TODO: subscribe two handlers to account.Deposited

account.Deposit(100m);

class DepositEventArgs : EventArgs
{
    public decimal Amount { get; }
    public decimal NewBalance { get; }
    public DepositEventArgs(decimal amount, decimal newBalance)
    {
        Amount = amount;
        NewBalance = newBalance;
    }
}

class BankAccount
{
    public decimal Balance { get; private set; }
    public event EventHandler<DepositEventArgs> Deposited;

    public void Deposit(decimal amount)
    {
        // TODO: add to Balance, then raise Deposited with a DepositEventArgs
    }
}

BankAccount account = new BankAccount();

account.Deposited += (sender, e) =>
    Console.WriteLine($"Receipt: deposited {e.Amount:C}. Balance: {e.NewBalance:C}");

account.Deposited += (sender, e) =>
    Console.WriteLine($"You earned {(int)(e.Amount)} bonus points!");

account.Deposit(100m);

class DepositEventArgs : EventArgs
{
    public decimal Amount { get; }
    public decimal NewBalance { get; }
    public DepositEventArgs(decimal amount, decimal newBalance)
    {
        Amount = amount;
        NewBalance = newBalance;
    }
}

class BankAccount
{
    public decimal Balance { get; private set; }
    public event EventHandler<DepositEventArgs> Deposited;

    public void Deposit(decimal amount)
    {
        Balance += amount;
        Deposited?.Invoke(this, new DepositEventArgs(amount, Balance));
    }
}

Receipt: deposited $100.00. Balance: $100.00
You earned 100 bonus points!

Summary

📚 Additional Resources

• Events — C# Programming Guide
• Handling and raising events — .NET
• EventHandler<TEventArgs> — API reference

🚀 What's Next?

You've now used delegates directly and through events. In Lesson 2.3: LINQ, you'll see delegates and lambdas at their most powerful — querying and transforming collections with beautifully concise code.