EventHandler delegate pattern in C Sharp (C#) - Step-by-Step Execution

Concept Flow - EventHandler delegate pattern

Define EventHandler delegate

↓

Create event using EventHandler

↓

Subscribe method to event

↓

Trigger event (Raise event)

↓

Invoke subscribed methods

↓

Methods respond to event

This flow shows how an EventHandler delegate is defined, an event is created and subscribed to, then triggered to call the subscribed methods.

Execution Sample

C Sharp (C#)

using System;

class Program {
  static event EventHandler MyEvent;

  static void Main() {
    MyEvent += Handler;
    MyEvent?.Invoke(null, EventArgs.Empty);
  }

  static void Handler(object? sender, EventArgs e) {
    Console.WriteLine("Event triggered!");
  }
}

This code defines an event using EventHandler, subscribes a method, then triggers the event to print a message.

Execution Table

Step	Action	EventHandler MyEvent	Output
1	Start program	null
2	Subscribe Handler to MyEvent	Handler method added
3	Invoke MyEvent	Handler method called	Event triggered!
4	Program ends	Handler method remains subscribed

💡 Program ends after event is triggered and Handler method runs

Variable Tracker

Variable	Start	After Step 2	After Step 3	Final
MyEvent	null	Handler method subscribed	Handler method subscribed	Handler method subscribed

Key Moments - 3 Insights

Why is MyEvent null at the start and not empty?

At start, no methods are subscribed, so MyEvent is null, not an empty list. See execution_table step 1.

What does the ?.Invoke syntax do?

It safely calls the event only if it's not null, preventing errors if no subscribers exist. See execution_table step 3.

Why does the Handler method receive two parameters?

EventHandler delegate requires sender and EventArgs parameters, even if unused. See code in execution_sample.

Visual Quiz - 3 Questions

Look at the execution table, what is the value of MyEvent after step 2?

A Handler method subscribed

B null

C Empty delegate

D Event triggered!

💡 Hint

Check the 'EventHandler MyEvent' column in row for step 2.

At which step does the program output "Event triggered!"?

A Step 1

B Step 3

C Step 2

D Step 4

💡 Hint

Look at the 'Output' column in the execution_table.

If no method was subscribed to MyEvent, what would happen at step 3?

A Program crashes with null reference error

B Handler method is called anyway

C Nothing happens, no output

D EventHandler becomes empty delegate

💡 Hint

The ?.Invoke syntax prevents calling null delegate, so no output occurs if no subscribers.

Concept Snapshot

EventHandler delegate pattern in C#:
- Define event: event EventHandler MyEvent;
- Subscribe: MyEvent += Handler;
- Trigger: MyEvent?.Invoke(sender, EventArgs.Empty);
- Handler signature: void Handler(object? sender, EventArgs e)
- ?.Invoke avoids null errors
- Used for simple event notification

Full Transcript

This example shows how to use the EventHandler delegate pattern in C#. First, an event named MyEvent is declared using the EventHandler delegate type. Initially, MyEvent is null because no methods are subscribed. Then, the Handler method is subscribed to MyEvent using +=. When the event is triggered by calling MyEvent?.Invoke(null, EventArgs.Empty), the Handler method runs and prints "Event triggered!". The ?.Invoke syntax ensures the event is only called if it has subscribers, preventing errors. The Handler method must accept two parameters: sender and EventArgs, as required by EventHandler. This pattern allows simple event notification and handling in C# programs.

Practice

1. What is the main purpose of the EventHandler delegate in C#?

easy

A. To format strings for output

B. To create a new thread for event processing

C. To store data in a dictionary

D. To define a method signature for handling events

Solution

1. Step 1: Understand what a delegate does

   A delegate defines a method signature that can be used to call methods indirectly.

2. Step 2: Connect delegate to event handling

   The EventHandler delegate specifically defines the signature for methods that handle events.

3. Final Answer:

   To define a method signature for handling events -> Option D

4. Quick Check:

   EventHandler defines event method signature = D [OK]

Hint: EventHandler defines how event methods look [OK]

Common Mistakes:

• Confusing EventHandler with threading
• Thinking EventHandler stores data
• Mixing EventHandler with string formatting

2. Which of the following is the correct syntax to declare an event using the EventHandler delegate in a class?

easy

A. public event EventHandler MyEvent;

B. public EventHandler event MyEvent;

C. event public EventHandler MyEvent();

D. public void event EventHandler MyEvent;

Solution

1. Step 1: Recall event declaration syntax

   Events are declared with the keyword event followed by the delegate type and event name.

2. Step 2: Match correct syntax

   public event EventHandler MyEvent; matches the correct pattern.

3. Final Answer:

   public event EventHandler MyEvent; -> Option A

4. Quick Check:

   Event declaration = event + delegate + name [OK]

Hint: Remember: event keyword before delegate type [OK]

Common Mistakes:

• Placing 'event' after delegate type
• Adding parentheses after event name
• Using void instead of event keyword

3. What will be the output of the following code?

using System;
class Program {
    public static event EventHandler OnAction;
    static void Main() {
        OnAction += (sender, e) => Console.WriteLine("Action happened!");
        OnAction?.Invoke(null, EventArgs.Empty);
    }
}

medium

A. Action happened!

B. No output

C. NullReferenceException

D. Compilation error

Solution

1. Step 1: Understand event subscription

   The lambda expression subscribes a method that prints "Action happened!" to the event OnAction.

2. Step 2: Invoke the event safely

   The event is invoked with ?.Invoke, so it calls the subscribed method, printing the message.

3. Final Answer:

   Action happened! -> Option A

4. Quick Check:

   Subscribed event invoked prints message = A [OK]

Hint: ?.Invoke calls event only if not null [OK]

Common Mistakes:

• Forgetting to subscribe to the event
• Not using null-conditional operator causing errors
• Expecting no output without invocation

4. Identify the error in this event usage code:

public class Button {
    public event EventHandler Click;
    public void SimulateClick() {
        Click(null, EventArgs.Empty);
    }
}

medium

A. EventHandler delegate cannot use EventArgs.Empty

B. Event must be invoked with a sender object, not null

C. Event should be checked for null before invoking

D. SimulateClick method must be static

Solution

1. Step 1: Check event invocation safety

   Events can be null if no subscribers exist, so invoking without null check causes runtime error.

2. Step 2: Correct usage

   Use Click?.Invoke(this, EventArgs.Empty); to safely invoke the event.

3. Final Answer:

   Event should be checked for null before invoking -> Option C

4. Quick Check:

   Always check event for null before invoke [OK]

Hint: Use ?.Invoke to avoid null errors [OK]

Common Mistakes:

• Invoking event directly without null check
• Assuming sender cannot be null
• Making event handler static unnecessarily

5. You want to create a custom event that sends a string message to subscribers. Which is the best way to define the event and its arguments using the EventHandler pattern?

hard

A. Declare event as EventHandler and send string directly as sender parameter

B. Create a class inheriting from EventArgs with a string property, then declare event as EventHandler<YourArgs>

C. Use Action<string> delegate instead of EventHandler for the event

D. Declare event as EventHandler and ignore sending any data

Solution

1. Step 1: Understand custom event data

   To send extra info, create a class derived from EventArgs with needed properties.

2. Step 2: Use generic EventHandler with custom args

   Declare event as EventHandler<YourArgs> to pass the custom data safely.

3. Final Answer:

   Create a class inheriting from EventArgs with a string property, then declare event as EventHandler<YourArgs> -> Option B

4. Quick Check:

   Custom EventArgs + EventHandler<T> = B [OK]

Hint: Use EventHandler<T> with custom EventArgs for extra data [OK]

Common Mistakes:

• Passing data via sender parameter
• Using Action delegate instead of EventHandler
• Ignoring event data when needed