Event declaration syntax in C Sharp (C#) - Step-by-Step Execution

Concept Flow - Event declaration syntax

Declare delegate type

↓

Declare event using delegate

↓

Subscribe method to event

↓

Raise event to call subscribed methods

↓

End

This flow shows how to declare a delegate type, then declare an event using that delegate, subscribe methods to the event, and finally raise the event to call those methods.

Execution Sample

C Sharp (C#)

public delegate void Notify();
public class Process {
  public event Notify ProcessCompleted;
  public void Start() {
    ProcessCompleted?.Invoke();
  }
}

Declares a delegate, an event using that delegate, and raises the event inside a method.

Execution Table

Step	Action	Evaluation	Result
1	Declare delegate Notify	Defines a delegate type with no parameters	Delegate type Notify created
2	Declare event ProcessCompleted of type Notify	Event is declared but no subscribers yet	Event ProcessCompleted created, empty subscriber list
3	Subscribe method Handler1 to ProcessCompleted	Adds Handler1 to subscriber list	ProcessCompleted subscribers: [Handler1]
4	Call Start method	Inside Start, ProcessCompleted?.Invoke() called	Handler1 method invoked
5	Subscribe method Handler2 to ProcessCompleted	Adds Handler2 to subscriber list	ProcessCompleted subscribers: [Handler1, Handler2]
6	Call Start method again	ProcessCompleted?.Invoke() calls all subscribers	Handler1 and Handler2 methods invoked
7	Unsubscribe Handler1 from ProcessCompleted	Removes Handler1 from subscriber list	ProcessCompleted subscribers: [Handler2]
8	Call Start method again	Only Handler2 invoked	Handler2 method invoked
9	End	No more actions	Execution stops

💡 No more method calls; event raising stops

Variable Tracker

Variable	Start	After 3	After 5	After 7	Final
ProcessCompleted subscribers	[]	[Handler1]	[Handler1, Handler2]	[Handler2]	[Handler2]

Key Moments - 3 Insights

Why do we use a delegate before declaring an event?

The delegate defines the method signature that event handlers must follow. The event uses this delegate type to ensure only compatible methods can subscribe, as shown in step 1 and 2 of the execution_table.

What does the ?.Invoke() syntax mean when raising the event?

It safely calls the event only if there are subscribers. If no one subscribed, it prevents a null reference error. This is shown in step 4 where ProcessCompleted?.Invoke() is called.

Can multiple methods subscribe to the same event?

Yes, multiple methods can subscribe and all will be called when the event is raised. This is shown in steps 5 and 6 where Handler1 and Handler2 are both invoked.

Visual Quiz - 3 Questions

Look at the execution_table at step 3, what is the state of ProcessCompleted subscribers?

A []

B [Handler1]

C [Handler2]

D [Handler1, Handler2]

💡 Hint

Check the 'Result' column at step 3 in the execution_table.

At which step does the event have two subscribers?

A Step 5

B Step 7

C Step 3

D Step 8

💡 Hint

Look at the 'ProcessCompleted subscribers' in variable_tracker after step 5.

If we unsubscribe Handler2 at step 7 instead of Handler1, what would be the subscribers after step 7?

A []

B [Handler2]

C [Handler1]

D [Handler1, Handler2]

💡 Hint

Refer to variable_tracker and imagine removing Handler2 instead of Handler1 at step 7.

Concept Snapshot

Event declaration in C#:
- Declare a delegate type for method signature.
- Declare an event using that delegate.
- Subscribe methods to the event.
- Raise event with ?.Invoke() to call subscribers safely.
- Multiple subscribers allowed; unsubscribing removes them.

Full Transcript

This visual execution shows how to declare and use events in C#. First, a delegate type is declared to define the method signature for event handlers. Then, an event is declared using this delegate type. Methods can subscribe to this event, adding themselves to the subscriber list. When the event is raised using ?.Invoke(), all subscribed methods are called. The execution table traces subscribing, raising, and unsubscribing steps, showing how the subscriber list changes. Key moments clarify why delegates are needed, the safe invocation syntax, and multiple subscriptions. The visual quiz tests understanding of subscriber states at different steps. The snapshot summarizes the event declaration syntax and usage in simple steps.