Event-driven design pattern in C Sharp (C#) - Mini Project: Build & Apply

Event-driven design pattern

📖 Scenario: You are building a simple notification system where a Button can be clicked, and other parts of the program can react to this click event.This is like a real-world button that when pressed, triggers some action like turning on a light or playing a sound.

🎯 Goal: Create a basic event-driven program in C# where a Button class raises a Clicked event, and a Notifier class listens and responds by printing a message.

📋 What You'll Learn

Create a Button class with a Clicked event

Create a Notifier class with a method to handle the Clicked event

Raise the Clicked event when the button is pressed

Subscribe the Notifier to the Clicked event

Print a message when the event is handled

💡 Why This Matters

🌍 Real World

Event-driven design is used in user interfaces, games, and any program that reacts to user actions or other events.

💼 Career

Understanding events is essential for software developers working with GUI applications, web development, and real-time systems.

1

Create the Button class with a Clicked event

Create a class called Button with a public event Clicked of type EventHandler. Inside the class, add a method Press() that will later raise this event.

C Sharp (C#)

public class Button
{
    // Your code here
}

Hint

Use public event EventHandler? Clicked; to declare the event.

The Press method is empty for now.

2

Create the Notifier class with an event handler method

Create a class called Notifier with a public method OnButtonClicked that takes object? sender and EventArgs e as parameters. Inside this method, write code to print "Button was clicked!".

C Sharp (C#)

using System;

public class Button
{
    public event EventHandler? Clicked;

    public void Press()
    {
        // Event will be raised later
    }
}

public class Notifier
{
    // Your code here
}

Hint

The event handler method must match the EventHandler delegate signature.

3

Raise the Clicked event inside the Press method and subscribe the Notifier

Inside the Press() method of Button, raise the Clicked event safely using the null-conditional operator. Then, create a Button object and a Notifier object. Subscribe the Notifier's OnButtonClicked method to the Clicked event of the Button.

C Sharp (C#)

using System;

public class Button
{
    public event EventHandler? Clicked;

    public void Press()
    {
        // Raise the Clicked event here
    }
}

public class Notifier
{
    public void OnButtonClicked(object? sender, EventArgs e)
    {
        Console.WriteLine("Button was clicked!");
    }
}

// Your code here to create objects and subscribe

Hint

Use Clicked?.Invoke(this, EventArgs.Empty); to raise the event safely.

Subscribe with button.Clicked += notifier.OnButtonClicked;.

4

Press the button to trigger the event and print the message

In the Main method, after subscribing, call the Press() method on the button object to trigger the Clicked event and print "Button was clicked!".

C Sharp (C#)

using System;

public class Button
{
    public event EventHandler? Clicked;

    public void Press()
    {
        Clicked?.Invoke(this, EventArgs.Empty);
    }
}

public class Notifier
{
    public void OnButtonClicked(object? sender, EventArgs e)
    {
        Console.WriteLine("Button was clicked!");
    }
}

class Program
{
    static void Main()
    {
        Button button = new Button();
        Notifier notifier = new Notifier();
        button.Clicked += notifier.OnButtonClicked;
        // Your code here to press the button
    }
}

Hint

Call button.Press(); to trigger the event and see the message.

Practice

1. What is the main role of an event subscriber in the event-driven design pattern?

easy

A. To manage the program's user interface layout

B. To listen for events and respond when they occur

C. To store data for the program's use

D. To create and send events to other parts of the program

Solution

1. Step 1: Understand the roles in event-driven design

   In event-driven design, publishers send events and subscribers listen for these events.

2. Step 2: Identify subscriber's responsibility

   The subscriber's job is to react or respond when an event happens, meaning it listens and acts accordingly.

3. Final Answer:

   To listen for events and respond when they occur -> Option B

4. Quick Check:

   Subscriber listens and reacts = D [OK]

Hint: Subscribers always listen and react to events [OK]

Common Mistakes:

• Confusing subscriber with publisher
• Thinking subscriber creates events
• Assuming subscriber manages UI layout

2. Which of the following is the correct syntax to declare an event in C#?

easy

A. public void event MyEvent();

B. event public MyEvent EventHandler;

C. public event EventHandler MyEvent;

D. EventHandler public event MyEvent;

Solution

1. Step 1: Recall event declaration syntax in C#

   Events are declared with the keyword 'event' followed by a delegate type, then the event name.

2. Step 2: Check each option

   public event EventHandler MyEvent; matches the correct syntax: 'public event EventHandler MyEvent;'. Others have wrong order or keywords.

3. Final Answer:

   public event EventHandler MyEvent; -> Option C

4. Quick Check:

   Correct event declaration = B [OK]

Hint: Event declaration: 'public event DelegateType EventName;' [OK]

Common Mistakes:

• Mixing method and event syntax
• Wrong keyword order
• Missing 'event' keyword

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

using System;
class Program {
  public static event Action OnNotify;
  static void Main() {
    OnNotify += () => Console.WriteLine("Event triggered");
    OnNotify?.Invoke();
  }
}

medium

A. Event triggered

B. No output

C. Compilation error

D. Runtime exception

Solution

1. Step 1: Understand event subscription and invocation

   The event OnNotify is subscribed with a lambda that prints "Event triggered". The event is then invoked safely with ?.Invoke().

2. Step 2: Predict output

   Since OnNotify has a subscriber, invoking it calls the lambda, printing "Event triggered" to the console.

3. Final Answer:

   Event triggered -> Option A

4. Quick Check:

   Subscribed event invoked prints message = A [OK]

Hint: Subscribed event invocation prints output [OK]

Common Mistakes:

• Ignoring null-conditional operator ?.Invoke()
• Expecting no output without subscription
• Confusing event with method call syntax

4. Identify the error in this C# event-driven code snippet:

public class Publisher {
  public event EventHandler OnChange;
  public void Raise() {
    OnChange();
  }
}

medium

A. OnChange event is invoked without checking for null

B. EventHandler delegate is not declared

C. Raise method should be static

D. Event should be private

Solution

1. Step 1: Review event invocation rules

   Events can be null if no subscribers exist. Invoking without null check causes runtime error.

2. Step 2: Identify the error in code

   OnChange() is called directly without checking if OnChange is null, risking NullReferenceException.

3. Final Answer:

   OnChange event is invoked without checking for null -> Option A

4. Quick Check:

   Invoke event safely with null check = C [OK]

Hint: Always check event for null before invoking [OK]

Common Mistakes:

• Calling event without null check
• Assuming event is never null
• Misunderstanding event access modifiers

5. You want to design a system where multiple subscribers react differently to a button click event. Which approach best uses the event-driven pattern in C# to achieve this?

hard

A. Make subscribers poll the button state continuously in a loop

B. Create a list of methods and call them manually without events

C. Use a static method to handle all button clicks centrally

D. Declare a public event, let subscribers add their handlers, and invoke event on button click

Solution

1. Step 1: Understand event-driven design for multiple subscribers

   Events allow multiple subscribers to register handlers that get called automatically when the event fires.

2. Step 2: Evaluate options for best practice

   Declare a public event, let subscribers add their handlers, and invoke event on button click uses a public event and lets subscribers add handlers, which is the standard event-driven approach. Others are less efficient or not event-driven.

3. Final Answer:

   Declare a public event, let subscribers add their handlers, and invoke event on button click -> Option D

4. Quick Check:

   Use events for multiple subscriber reactions = A [OK]

Hint: Use events to notify multiple subscribers automatically [OK]

Common Mistakes:

• Manually calling subscriber methods instead of using events
• Using polling instead of event notifications
• Centralizing all logic in static methods