Raising events safely in C Sharp (C#) - Step-by-Step Execution

Concept Flow - Raising events safely

Define event handler variable

↓

Check if event handler is not null

↓

Skip raising event

↓

Invoke event handler

↓

Event subscribers run their methods

↓

End

This flow shows how to safely raise an event by first checking if there are subscribers before calling the event.

Execution Sample

C Sharp (C#)

public event EventHandler? MyEvent;

public void RaiseEvent()
{
    var handler = MyEvent;
    if (handler != null)
        handler(this, EventArgs.Empty);
}

This code safely raises an event by copying the event delegate to a local variable and checking for null before invoking.

Execution Table

Step	Action	Evaluation	Result
1	Copy MyEvent to handler	MyEvent is null or has subscribers	handler = MyEvent (snapshot)
2	Check if handler != null	If handler has subscribers	True or False
3	If True, invoke handler(this, EventArgs.Empty)	Calls all subscribed methods	Subscribers run their event methods
4	If False, skip invocation	No subscribers	No methods called
5	End of RaiseEvent method	Event raised safely or skipped	Method returns

💡 Execution stops after event is invoked or skipped because no subscribers exist.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3/4	Final
MyEvent	null or delegate list	Same as start	Same as start	Same as start	Same as start
handler	undefined	Copy of MyEvent	Same as after step 1	Invoked or not invoked	Same as after step 1

Key Moments - 2 Insights

Why do we copy the event delegate to a local variable before checking for null?

Copying to a local variable prevents the event from becoming null between the null check and invocation, avoiding a possible NullReferenceException as shown in step 1 and 2 of the execution_table.

What happens if we invoke the event without checking for null?

If no subscribers exist (MyEvent is null), invoking it directly causes a NullReferenceException. The execution_table step 2 shows the importance of the null check to avoid this.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of 'handler' after step 1 if MyEvent has two subscribers?

A A copy of MyEvent delegate with two subscribers

B null

C An empty delegate

D Throws an exception

💡 Hint

Refer to execution_table row 1 where handler is assigned a snapshot of MyEvent.

At which step does the program decide not to invoke the event because there are no subscribers?

A Step 1

B Step 3

C Step 4

D Step 2

💡 Hint

Check execution_table row 4 where invocation is skipped if handler is null.

If we remove the local copy and invoke MyEvent directly, what risk do we introduce?

A No risk, code runs faster

B Possible NullReferenceException if subscribers unsubscribe between check and invoke

C Event will never be raised

D Subscribers will be called twice

💡 Hint

See key_moments explanation about copying to local variable to avoid null changes.

Concept Snapshot

Raising events safely in C#:
- Copy event delegate to local variable
- Check if local variable is not null
- Invoke local variable to raise event
- Prevents NullReferenceException if subscribers change
- Always use this pattern when raising events

Full Transcript

This example shows how to raise events safely in C#. First, the event delegate is copied to a local variable to prevent it from changing between the null check and invocation. Then, the code checks if the local variable is not null, meaning there are subscribers. If so, it invokes the event, calling all subscribed methods. If no subscribers exist, it skips invocation to avoid errors. This pattern prevents runtime exceptions and ensures safe event raising.

Practice

1. What is the main reason to raise events safely in C#?

easy

A. To automatically unsubscribe all handlers after raising

B. To avoid errors when no event handlers are attached

C. To allow multiple events to be raised simultaneously

D. To improve the speed of event invocation

Solution

1. Step 1: Understand event raising basics

   Raising an event without handlers can cause a null reference error.

2. Step 2: Identify the purpose of safe raising

   Safe raising checks if handlers exist before invoking to prevent errors.

3. Final Answer:

   To avoid errors when no event handlers are attached -> Option B

4. Quick Check:

   Safe event raising prevents null errors [OK]

Hint: Check for null handlers before invoking events [OK]

Common Mistakes:

• Assuming events always have handlers
• Not checking for null before invoking
• Confusing event raising with event subscription

2. Which of the following is the correct syntax to raise an event safely using the null-conditional operator?

easy

A. MyEvent.Invoke(this, EventArgs.Empty);

B. if (MyEvent != null) MyEvent(this, EventArgs.Empty);

C. MyEvent?.Invoke(this, EventArgs.Empty);

D. MyEvent(this, EventArgs.Empty);

Solution

1. Step 1: Recall null-conditional operator usage

   The ?. operator safely calls a method only if the delegate is not null.

2. Step 2: Match syntax for safe event raising

   Using MyEvent?.Invoke(...) safely raises the event without null checks.

3. Final Answer:

   MyEvent?.Invoke(this, EventArgs.Empty); -> Option C

4. Quick Check:

   ?.Invoke is the safe call syntax [OK]

Hint: Use ?.Invoke to call events safely in one line [OK]

Common Mistakes:

• Forgetting the ?. operator and causing null exceptions
• Using Invoke without null checks
• Using if-check but missing parentheses

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

public class Publisher {
    public event EventHandler? MyEvent;
    public void Raise() {
        var handler = MyEvent;
        if (handler != null) handler(this, EventArgs.Empty);
        else Console.WriteLine("No subscribers");
    }
}

var pub = new Publisher();
pub.Raise();

medium

A. No subscribers

B. NullReferenceException

C. Event raised successfully

D. Compilation error

Solution

1. Step 1: Analyze event subscription

   No handlers are attached to MyEvent before calling Raise.

2. Step 2: Check event invocation logic

   Since handler is null, the else branch prints "No subscribers".

3. Final Answer:

   No subscribers -> Option A

4. Quick Check:

   No handlers means else branch runs [OK]

Hint: If no handlers, else branch prints message [OK]

Common Mistakes:

• Expecting event to raise without subscribers
• Assuming null check is unnecessary
• Confusing event invocation with subscription

4. Identify the error in this event raising code:

public event EventHandler? MyEvent;

public void Raise() {
    if (MyEvent != null)
        MyEvent(this, EventArgs.Empty);
}

medium

A. Event should be invoked with Invoke() method

B. No error, code is safe

C. Missing null-conditional operator

D. Possible race condition if handlers change after null check

Solution

1. Step 1: Understand event invocation timing

   Between null check and invocation, handlers can unsubscribe causing null reference.

2. Step 2: Identify race condition risk

   Copying delegate to local variable avoids this race condition.

3. Final Answer:

   Possible race condition if handlers change after null check -> Option D

4. Quick Check:

   Null check alone is not thread-safe [OK]

Hint: Copy event delegate to local variable before invoking [OK]

Common Mistakes:

• Ignoring race conditions in multithreaded code
• Assuming null check guarantees safety
• Thinking Invoke() method is mandatory

5. You want to raise an event safely and also log every time the event is raised. Which of the following is the best approach?

public event EventHandler? MyEvent;

public void Raise() {
    var handler = MyEvent;
    if (handler != null) {
        handler(this, EventArgs.Empty);
        Console.WriteLine("Event raised");
    } else {
        Console.WriteLine("No subscribers");
    }
}

hard

A. This code is correct and safely raises the event with logging

B. Logging should be done before invoking the event

C. Use MyEvent?.Invoke(this, EventArgs.Empty) without local copy

D. Remove null check and catch exceptions instead

Solution

1. Step 1: Check safe event raising

   Copying MyEvent to handler ensures safe invocation without race conditions.

2. Step 2: Verify logging placement

   Logging after invocation confirms event was raised; else logs no subscribers.

3. Final Answer:

   This code is correct and safely raises the event with logging -> Option A

4. Quick Check:

   Local copy + logging after invoke is best practice [OK]

Hint: Copy event, invoke, then log success [OK]

Common Mistakes:

• Logging before event may mislead if event throws
• Skipping local copy risks race conditions
• Ignoring null checks causes exceptions