Custom event arguments in C Sharp (C#) - Step-by-Step Execution

Concept Flow - Custom event arguments

Define EventArgs subclass

↓

Create event using custom args

↓

Subscribe event handler

↓

Raise event with custom args

↓

Handler receives custom args

↓

Use data from custom args

This flow shows how to create and use custom event arguments in C# events, from defining the args class to handling the event.

Execution Sample

C Sharp (C#)

public class MyEventArgs : EventArgs {
  public int Value { get; }
  public MyEventArgs(int value) => Value = value;
}

public event EventHandler<MyEventArgs> MyEvent;

MyEvent?.Invoke(this, new MyEventArgs(42));

Defines a custom event argument class with a value, then raises an event passing that value.

Execution Table

Step	Action	Evaluation	Result
1	Define MyEventArgs class	Class created with int Value property	Ready to use custom args
2	Declare event MyEvent with MyEventArgs	Event handler type set	Event ready for subscription
3	Subscribe handler to MyEvent	Handler method linked	Handler will be called on event
4	Raise MyEvent with new MyEventArgs(42)	Invoke event if not null	Handler called with Value=42
5	Handler receives event args	Access args.Value	Handler uses Value=42
6	End of event raising	No more handlers	Execution continues

💡 Event raised once, handler executed, no more events

Variable Tracker

Variable	Start	After Step 4	After Step 5	Final
MyEvent	null or empty	Has handler subscribed	Handler invoked	Remains subscribed
MyEventArgs instance	none	Created with Value=42	Passed to handler	Used in handler

Key Moments - 3 Insights

Why do we create a class inheriting from EventArgs?

Because custom event data needs a container class; inheriting EventArgs is the standard pattern, as shown in Step 1 of the execution_table.

How does the event handler receive the custom data?

The handler gets the custom args object as a parameter when the event is invoked, shown in Step 5 where args.Value is accessed.

What happens if no handler is subscribed when the event is raised?

The event invocation checks for null (Step 4), so if no handler is subscribed, nothing happens and no error occurs.

Visual Quiz - 3 Questions

Look at the execution_table at Step 4, what value is passed in the custom event args?

A 0

B 42

C null

D EventArgs default

💡 Hint

Check the 'Result' column in Step 4 showing 'Handler called with Value=42'

At which step does the event handler get called?

A Step 5

B Step 2

C Step 4

D Step 3

💡 Hint

Step 5 shows 'Handler receives event args' and uses the value

If no handler is subscribed, what happens when the event is raised?

A NullReferenceException occurs

B Program crashes

C Event is ignored safely

D Handler is called with null args

💡 Hint

Step 4 mentions 'Invoke event if not null' meaning it checks before calling

Concept Snapshot

Custom event arguments in C#:
- Create a class inheriting EventArgs with your data
- Declare event using EventHandler<T> with your class
- Raise event passing new instance with data
- Handlers receive your custom data via args parameter
- Always check event is not null before invoking

Full Transcript

This visual execution shows how to use custom event arguments in C#. First, you define a class inheriting from EventArgs to hold your custom data. Then you declare an event using EventHandler with your custom args type. You subscribe a handler method to this event. When you raise the event, you create a new instance of your custom args with the data you want to send and invoke the event. The handler receives this custom args object and can access the data inside. The execution table traces these steps clearly, showing variable states and event flow. Key moments clarify why we inherit EventArgs and how handlers get the data. The quiz tests understanding of the event data, handler call timing, and safe invocation. This pattern helps pass extra information with events in a clean, standard way.

Practice

1. What is the main purpose of creating a custom class that inherits from EventArgs in C#?

easy

A. To replace the EventHandler delegate entirely.

B. To prevent events from being raised multiple times.

C. To send additional data with an event when it is raised.

D. To automatically handle exceptions in event handlers.

Solution

1. Step 1: Understand the role of EventArgs

   The EventArgs class is used to pass data with events. Creating a custom class inheriting from it allows adding extra information.

2. Step 2: Identify the purpose of custom event arguments

   Custom event argument classes let you send specific data related to the event, making event communication clearer.

3. Final Answer:

   To send additional data with an event when it is raised. -> Option C

4. Quick Check:

   Custom EventArgs = Extra event data [OK]

Hint: Custom EventArgs carry extra info with events [OK]

Common Mistakes:

• Thinking custom EventArgs replace EventHandler delegate
• Believing custom EventArgs stop event repetition
• Assuming custom EventArgs handle exceptions automatically

2. Which of the following is the correct way to declare a custom event argument class named MyEventArgs with a string property Message?

easy

A. public class MyEventArgs : EventArgs { public int Message { get; set; } }

B. public class MyEventArgs { public string Message { get; set; } }

C. public class MyEventArgs : EventHandler { public string Message; }

D. public class MyEventArgs : EventArgs { public string Message { get; set; } }

Solution

1. Step 1: Check inheritance from EventArgs

   The custom event argument class must inherit from EventArgs to be used properly in events.

2. Step 2: Verify property type and syntax

   The property Message should be a string with get and set accessors for data storage.

3. Final Answer:

   public class MyEventArgs : EventArgs { public string Message { get; set; } } -> Option D

4. Quick Check:

   Custom EventArgs inherit EventArgs + correct property type [OK]

Hint: Custom EventArgs must inherit EventArgs and use correct property types [OK]

Common Mistakes:

• Forgetting to inherit from EventArgs
• Using EventHandler as base class instead of EventArgs
• Declaring property with wrong type

3. Consider the following code snippet:

public class MyEventArgs : EventArgs { public int Number { get; set; } }

public class Publisher {
    public event EventHandler<MyEventArgs> OnNumberChanged;
    public void ChangeNumber(int num) {
        OnNumberChanged?.Invoke(this, new MyEventArgs { Number = num });
    }
}

public class Subscriber {
    public void Subscribe(Publisher pub) {
        pub.OnNumberChanged += HandleNumberChanged;
    }
    private void HandleNumberChanged(object sender, MyEventArgs e) {
        Console.WriteLine($"Number is {e.Number}");
    }
}

// Main method
var pub = new Publisher();
var sub = new Subscriber();
sub.Subscribe(pub);
pub.ChangeNumber(42);

What will be the output when this code runs?

medium

A. Number is 42

B. Number is 0

C. No output, event not raised

D. Compilation error due to event handler signature

Solution

1. Step 1: Understand event raising and subscription

   The Publisher raises OnNumberChanged event with MyEventArgs containing the number passed.

2. Step 2: Check subscriber's event handler output

   The subscriber prints the Number property from the event args, which is set to 42.

3. Final Answer:

   Number is 42 -> Option A

4. Quick Check:

   Event raised with Number=42 prints "Number is 42" [OK]

Hint: Event args data prints exactly as passed in event [OK]

Common Mistakes:

• Assuming event is not raised or subscribed
• Confusing default values with passed values
• Mistaking event handler signature causing errors

4. The following code attempts to raise a custom event with arguments but causes a runtime error. What is the most likely cause?

public class MyEventArgs : EventArgs { public string Info { get; set; } }

public class Publisher {
    public event EventHandler<MyEventArgs> OnInfoChanged;
    public void RaiseEvent() {
        OnInfoChanged(this, new MyEventArgs { Info = "Hello" });
    }
}

// Usage
var pub = new Publisher();
pub.RaiseEvent();

medium

A. OnInfoChanged event is null because no subscribers are attached.

B. MyEventArgs does not inherit from EventArgs.

C. Event handler signature does not match the event declaration.

D. The Info property is not initialized before raising the event.

Solution

1. Step 1: Check event invocation safety

   The event OnInfoChanged is invoked without checking if it has subscribers, so if null, it causes a runtime NullReferenceException.

2. Step 2: Identify missing subscriber check

   Before invoking, the code should check if OnInfoChanged is not null to avoid errors.

3. Final Answer:

   OnInfoChanged event is null because no subscribers are attached. -> Option A

4. Quick Check:

   Invoke event without subscribers = NullReferenceException [OK]

Hint: Always check event is not null before invoking [OK]

Common Mistakes:

• Forgetting to check event for null before invoking
• Assuming event has subscribers by default
• Confusing property initialization with event subscription

5. You want to create a custom event argument class ProgressEventArgs that includes a percentage (int) and a message (string). You also want to raise an event ProgressChanged in a class Downloader that sends this data. Which of the following code snippets correctly implements this scenario?

hard

A. public class ProgressEventArgs {
public int Percentage { get; set; }
public string Message { get; set; }
}

public class Downloader {
public event EventHandler ProgressChanged;
public void ReportProgress(int percent, string msg) {
ProgressChanged?.Invoke(this, new ProgressEventArgs { Percentage = percent, Message = msg });
}
}

B. public class ProgressEventArgs : EventArgs {
public int Percentage { get; }
public string Message { get; }
public ProgressEventArgs(int percentage, string message) {
Percentage = percentage;
Message = message;
}
}

public class Downloader {
public event EventHandler<ProgressEventArgs> ProgressChanged;
public void ReportProgress(int percent, string msg) {
ProgressChanged?.Invoke(this, new ProgressEventArgs(percent, msg));
}
}

C. public class ProgressEventArgs : EventArgs {
public int Percentage;
public string Message;
}

public class Downloader {
public event EventHandler<ProgressEventArgs> ProgressChanged;
public void ReportProgress(int percent, string msg) {
ProgressChanged(this, new ProgressEventArgs { Percentage = percent, Message = msg });
}
}

D. public class ProgressEventArgs : EventArgs {
public int Percentage { get; set; }
public string Message { get; set; }
}

public class Downloader {
public event EventHandler<ProgressEventArgs> ProgressChanged;
public void ReportProgress(int percent, string msg) {
ProgressChanged(this, new ProgressEventArgs { Percentage = percent, Message = msg });
}
}

Solution

1. Step 1: Define immutable custom event args with constructor

   public class ProgressEventArgs : EventArgs { public int Percentage { get; } public string Message { get; } public ProgressEventArgs(int percentage, string message) { Percentage = percentage; Message = message; } } public class Downloader { public event EventHandler<ProgressEventArgs> ProgressChanged; public void ReportProgress(int percent, string msg) { ProgressChanged?.Invoke(this, new ProgressEventArgs(percent, msg)); } } defines ProgressEventArgs inheriting from EventArgs with readonly properties set via constructor, which is a good practice.

2. Step 2: Raise event safely with null check

   public class Downloader { public event EventHandler<ProgressEventArgs> ProgressChanged; public void ReportProgress(int percent, string msg) { ProgressChanged?.Invoke(this, new ProgressEventArgs(percent, msg)); } } uses null-conditional operator ?. to safely raise the event with the new event args instance.

3. Final Answer:

   public class ProgressEventArgs : EventArgs { public int Percentage { get; } public string Message { get; } public ProgressEventArgs(int percentage, string message) { Percentage = percentage; Message = message; } } public class Downloader { public event EventHandler<ProgressEventArgs> ProgressChanged; public void ReportProgress(int percent, string msg) { ProgressChanged?.Invoke(this, new ProgressEventArgs(percent, msg)); } } -> Option B

4. Quick Check:

   Immutable EventArgs via ctor + safe ?.Invoke [OK]

Hint: Use constructor for EventArgs properties and null-check event before invoke [OK]

Common Mistakes:

• Not inheriting from EventArgs
• Using wrong event handler delegate type
• Invoking event without null check
• Using public fields instead of properties