EventHandler delegate pattern in C Sharp (C#) - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this event subscription code?

Consider the following C# code using the EventHandler delegate pattern. What will be printed when the program runs?

C Sharp (C#)

using System;

class Publisher
{
    public event EventHandler? OnChange;

    public void RaiseEvent()
    {
        OnChange?.Invoke(this, EventArgs.Empty);
    }
}

class Program
{
    static void Main()
    {
        Publisher pub = new Publisher();
        pub.OnChange += Handler1;
        pub.OnChange += Handler2;
        pub.RaiseEvent();
    }

    static void Handler1(object? sender, EventArgs e)
    {
        Console.WriteLine("Handler1 called");
    }

    static void Handler2(object? sender, EventArgs e)
    {
        Console.WriteLine("Handler2 called");
    }
}

A No output

B Handler2 called\nHandler1 called

C Handler1 called

D Handler1 called\nHandler2 called

💡 Hint

Events call their subscribed handlers in the order they were added.

The event OnChange has two handlers added: Handler1 then Handler2. When RaiseEvent is called, both handlers run in order, printing their messages.

❓ Predict Output

intermediate

What happens if no handlers are subscribed?

What is the output of this code when RaiseEvent is called but no handlers are subscribed?

C Sharp (C#)

using System;

class Publisher
{
    public event EventHandler? OnChange;

    public void RaiseEvent()
    {
        OnChange?.Invoke(this, EventArgs.Empty);
        Console.WriteLine("Event raised");
    }
}

class Program
{
    static void Main()
    {
        Publisher pub = new Publisher();
        pub.RaiseEvent();
    }
}

A NullReferenceException

B Compilation error

C Event raised

D No output

💡 Hint

The null-conditional operator ?. prevents errors if no handlers exist.

The event OnChange is null because no handlers are subscribed. The ?.Invoke safely skips calling handlers. Then the message "Event raised" is printed.

🔧 Debug

advanced

Why does this event handler code cause a runtime error?

Examine this code. Why does it throw a NullReferenceException when RaiseEvent is called?

C Sharp (C#)

using System;

class Publisher
{
    public event EventHandler OnChange;

    public void RaiseEvent()
    {
        OnChange(this, EventArgs.Empty);
    }
}

class Program
{
    static void Main()
    {
        Publisher pub = new Publisher();
        pub.RaiseEvent();
    }
}

A The event OnChange must be static to be invoked.

B The event OnChange is null because no handlers are subscribed, so calling it causes NullReferenceException.

C The event OnChange requires a custom delegate type, not EventHandler.

D The RaiseEvent method must be async to call the event.

💡 Hint

Events are null if no handlers are attached. Calling a null delegate causes an error.

Because no handlers are subscribed, OnChange is null. Calling OnChange(this, EventArgs.Empty) without checking causes a NullReferenceException. Using OnChange?.Invoke(...) avoids this.

📝 Syntax

advanced

Which option correctly declares an event using EventHandler?

Which of the following is the correct way to declare an event named OnChange using the EventHandler delegate?

A public event EventHandler OnChange;

B public EventHandler OnChange();

C public event void OnChange(EventHandler handler);

D public delegate EventHandler OnChange;

💡 Hint

Events use the event keyword followed by the delegate type and event name.

Option A correctly declares an event named OnChange of type EventHandler. Other options are invalid syntax for events.

🚀 Application

expert

How many handlers are called and what is the output?

Given this code, how many handlers are called and what is the exact output?

C Sharp (C#)

using System;

class Publisher
{
    public event EventHandler? OnChange;

    public void RaiseEvent()
    {
        OnChange?.Invoke(this, EventArgs.Empty);
    }
}

class Program
{
    static void Main()
    {
        Publisher pub = new Publisher();
        pub.OnChange += Handler1;
        pub.OnChange += Handler2;
        pub.OnChange -= Handler1;
        pub.RaiseEvent();
    }

    static void Handler1(object? sender, EventArgs e)
    {
        Console.WriteLine("Handler1 called");
    }

    static void Handler2(object? sender, EventArgs e)
    {
        Console.WriteLine("Handler2 called");
    }
}

A One handler called\nHandler2 called

B Two handlers called\nHandler1 called\nHandler2 called

C No handlers called\nNo output

D One handler called\nHandler1 called

💡 Hint

Removing a handler unsubscribes it from the event.

Initially, both Handler1 and Handler2 are subscribed. Then Handler1 is removed. So only Handler2 runs, printing "Handler2 called" once.