Events

"Let me know when something happens"

A download finishes. A temperature crosses a limit. A user clicks a button. Often several parts of a program care about such moments — update the UI, write a log, send an alert — and the object where it happens shouldn't need to know about all of them.

Events solve this with the publisher/subscriber pattern:

• The publisher declares an event and raises it when something happens.
• Any number of subscribers attach handlers, and get called each time.

Declaring and raising an event

class Downloader
{
    public event EventHandler<string>? Completed;     // the event
 
    public void Download(string url)
    {
        // ... download the file ...
        Completed?.Invoke(this, url);                 // raise it
    }
}

• event + a delegate type declares the event. EventHandler<T> is the standard shape: (object? sender, T args).
• ?.Invoke(...) raises it — the ?. matters, because an event with no subscribers is null.
• By convention, sender is the object raising the event: this.

Subscribing

var downloader = new Downloader();
 
downloader.Completed += (sender, url) => Console.WriteLine($"Done: {url}");
downloader.Completed += LogCompletion;     // a method works too
 
downloader.Download("https://example.com/file.zip");
// Done: https://example.com/file.zip
// [log] https://example.com/file.zip
 
void LogCompletion(object? sender, string url) => Console.WriteLine($"[log] {url}");

Handlers run in the order they were added, synchronously, when the event is raised.

Unsubscribing

downloader.Completed -= LogCompletion;

To unsubscribe a lambda, you must keep a reference to the same delegate:

EventHandler<string> handler = (s, url) => Console.WriteLine(url);
downloader.Completed += handler;
downloader.Completed -= handler;      // works

Why the event keyword?

You could expose a public delegate field instead, but then anyone could raise it or replace all its handlers with =. The event keyword restricts outside code to += and -=; only the declaring class can raise it.

Custom event arguments

When you need to pass several values, define an arguments type — a record works nicely:

record OrderPlacedEventArgs(int OrderId, decimal Total);
 
class Shop
{
    public event EventHandler<OrderPlacedEventArgs>? OrderPlaced;
 
    public void PlaceOrder(int id, decimal total)
    {
        // ... save the order ...
        OrderPlaced?.Invoke(this, new OrderPlacedEventArgs(id, total));
    }
}
 
shop.OrderPlaced += (_, e) => Console.WriteLine($"Order {e.OrderId}: {e.Total:F2}");

Where you'll meet events

• UI frameworks (Blazor, WPF, MAUI): Click, TextChanged…
• INotifyPropertyChanged: the PropertyChanged event powers data binding.
• .NET APIs: FileSystemWatcher.Changed, Process.Exited, AppDomain.UnhandledException.

In backend systems, the same idea scales up into domain events and message queues — publishers and subscribers in different services. You'll see those in Backend Fundamentals and Architecture.

Try it

Key takeaways

• Events implement publisher/subscriber: publishers raise, subscribers handle.
• Declare with public event EventHandler<T>? Name; and raise with Name?.Invoke(this, args).
• Subscribe with +=, unsubscribe with -= — keep a reference to lambdas you'll remove.
• Unsubscribe to avoid keeping subscribers alive longer than intended.