Event unsubscription and memory in C Sharp (C#) - Step-by-Step Execution

Concept Flow - Event unsubscription and memory

Subscribe event handler

↓

Event raised

↓

Handler called

↓

Unsubscribe event handler

↓

Event raised again

↓

Handler NOT called

↓

Memory freed if no other refs

This flow shows subscribing an event handler, calling it when event fires, then unsubscribing so it no longer runs and memory can be freed.

Execution Sample

C Sharp (C#)

using System;

class Publisher {
  public event Action? OnChange;
  public void Raise() => OnChange?.Invoke();
}

var pub = new Publisher();
void Handler() => Console.WriteLine("Called");
pub.OnChange += Handler;
pub.Raise();
pub.OnChange -= Handler;
pub.Raise();

This code subscribes a handler to an event, raises the event (handler runs), unsubscribes, then raises again (handler does not run).

Execution Table

Step	Action	Event Handler List	Output
1	Create Publisher instance	empty
2	Define Handler method	empty
3	Subscribe Handler to OnChange	Handler
4	Raise event (pub.Raise())	Handler	Called
5	Unsubscribe Handler from OnChange	empty
6	Raise event again (pub.Raise())	empty

💡 Event handler list empty after unsubscription, so no output on second raise.

Variable Tracker

Variable	Start	After Step 3	After Step 5	Final
pub.OnChange	null	Handler	null	null

Key Moments - 2 Insights

Why does the handler not run after unsubscription?

Because in step 5 the handler is removed from the event list, so at step 6 the event has no handlers to call (see execution_table rows 5 and 6).

How does unsubscription help with memory?

If the handler is not unsubscribed, the event publisher keeps a reference to it, preventing garbage collection. Unsubscribing removes this reference, allowing memory to be freed.

Visual Quiz - 3 Questions

Look at the execution_table, what is the event handler list after step 3?

A empty

B null

C Handler

D Multiple handlers

💡 Hint

Check the 'Event Handler List' column at step 3 in execution_table.

At which step does the event handler get removed?

A Step 3

B Step 5

C Step 2

D Step 6

💡 Hint

Look at the 'Action' column in execution_table for when unsubscription happens.

If we did not unsubscribe the handler, what would happen at step 6?

A Handler runs again

B No output

C Error thrown

D Event handler list becomes empty

💡 Hint

Refer to the output column at step 4 and consider what happens if handler remains subscribed.

Concept Snapshot

Event subscription adds handlers to a list.
Raising event calls all handlers.
Unsubscription removes handlers.
Without unsubscription, handlers stay referenced.
This can cause memory leaks.
Always unsubscribe to free memory.

Full Transcript

This example shows how subscribing an event handler adds it to the event's internal list. When the event is raised, all subscribed handlers run. Unsubscribing removes the handler from the list, so it no longer runs when the event fires. This also allows the handler to be garbage collected, preventing memory leaks. The execution table traces each step: creating the publisher, subscribing the handler, raising the event (handler runs), unsubscribing, and raising again (no handler runs). The variable tracker shows the event handler list changing from null to containing the handler and back to null. Key moments clarify why unsubscription stops the handler from running and why it is important for memory management. The quiz tests understanding of the event handler list state and effects of unsubscription.