EventHandler delegate pattern in C Sharp (C#) - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the purpose of the EventHandler delegate in C#?

The EventHandler delegate defines a method signature for handling events. It allows methods to respond to events with a sender object and event data.

beginner

What are the parameters of the EventHandler delegate?

The EventHandler delegate has two parameters: object sender which is the source of the event, and EventArgs e which contains event data.

beginner

How do you subscribe to an event using the EventHandler delegate?

You subscribe by adding a method matching the EventHandler signature to the event using the += operator, for example: myObject.MyEvent += MyEventHandlerMethod;

beginner

What is the role of the sender parameter in an EventHandler method?

The sender parameter identifies the object that raised the event, allowing the event handler to know the source of the event.

intermediate

Why is it recommended to use EventHandler or EventHandler<T> delegates for events?

Using EventHandler or EventHandler<T> provides a standard, consistent pattern for events, making code easier to understand and maintain.

What is the correct signature of the EventHandler delegate?

A void Handler()

B int Handler(object sender)

C void Handler(object sender, EventArgs e)

D bool Handler(object sender, EventArgs e)

The EventHandler delegate expects a method that returns void and takes two parameters: an object sender and EventArgs e.

How do you raise an event using the EventHandler delegate safely?

A Check if the event is not null, then invoke it with sender and EventArgs

B Call the event directly without checking for null

C Assign null to the event before invoking

D Use a try-catch block without checking for null

You should check if the event is not null before invoking it to avoid NullReferenceException.

Which of these is a common use of EventHandler<T>?

A To handle events with no data

B To handle events with multiple senders

C To handle events asynchronously

D To handle events with custom event data

EventHandler<T> allows passing custom event data by specifying a type derived from EventArgs.

What does the += operator do in event subscription?

A Adds an event handler

B Removes an event handler

C Invokes an event handler

D Declares an event

The += operator adds a method to the event's invocation list.

What type must the second parameter of an EventHandler delegate be?

A string

B EventArgs or a subclass

C object

D int

The second parameter must be EventArgs or a type derived from EventArgs to carry event data.

Explain the EventHandler delegate pattern and how it is used to handle events in C#.

Think about how methods listen and respond to events using a standard signature.

Describe the steps to create, subscribe, and raise an event using the EventHandler delegate.

Imagine you want to notify other parts of your program when something happens.

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