Custom event arguments in C Sharp (C#) - Mini Project: Build & Apply

Custom Event Arguments in C#

📖 Scenario: You are building a simple notification system where a TemperatureSensor reports temperature changes. You want to send extra information about the temperature when it changes.

🎯 Goal: Create a custom event argument class to hold the temperature value, raise an event with this custom argument, and handle the event to display the temperature.

📋 What You'll Learn

Create a class called TemperatureChangedEventArgs that inherits from EventArgs and has a property Temperature of type double.

Create a class called TemperatureSensor with an event TemperatureChanged using EventHandler<TemperatureChangedEventArgs>.

Add a method SetTemperature in TemperatureSensor that raises the TemperatureChanged event with the new temperature.

Create a Main method that creates a TemperatureSensor, subscribes to TemperatureChanged, and prints the temperature when the event is raised.

💡 Why This Matters

🌍 Real World

Custom event arguments are used in real applications to send extra information when something important happens, like sensor updates or user actions.

💼 Career

Understanding custom events is important for building interactive and responsive applications in C# and many other programming environments.

1

Create the custom event argument class

Create a public class called TemperatureChangedEventArgs that inherits from EventArgs. Add a public property Temperature of type double with a getter and a constructor that sets this property.

C Sharp (C#)

# Your code here

Hint

Remember to inherit from EventArgs and create a constructor that sets the Temperature property.

2

Create the TemperatureSensor class with an event

Create a public class called TemperatureSensor. Inside it, declare a public event called TemperatureChanged of type EventHandler<TemperatureChangedEventArgs>. Also, add a private field _temperature of type double.

C Sharp (C#)

using System;

public class TemperatureChangedEventArgs : EventArgs
{
    public double Temperature { get; }

    public TemperatureChangedEventArgs(double temperature)
    {
        Temperature = temperature;
    }
}

// Your code here

Hint

Declare the event using EventHandler<TemperatureChangedEventArgs> and a private field to store temperature.

3

Add SetTemperature method to raise the event

In the TemperatureSensor class, add a public method called SetTemperature that takes a double parameter called temperature. Inside this method, set the private field _temperature to the new value, then raise the TemperatureChanged event if it is not null, passing this and a new TemperatureChangedEventArgs with the new temperature.

C Sharp (C#)

using System;

public class TemperatureChangedEventArgs : EventArgs
{
    public double Temperature { get; }

    public TemperatureChangedEventArgs(double temperature)
    {
        Temperature = temperature;
    }
}

public class TemperatureSensor
{
    private double _temperature;
    public event EventHandler TemperatureChanged;

    // Add SetTemperature method below
    // Your code here
}

Hint

Use the null-conditional operator ?. to safely raise the event.

4

Subscribe to the event and print the temperature

Add a Main method inside a Program class. Inside Main, create a new TemperatureSensor object called sensor. Subscribe to the TemperatureChanged event with a lambda that takes sender and e and prints "Temperature changed to {e.Temperature}". Then call sensor.SetTemperature(25.5).

C Sharp (C#)

using System;

public class TemperatureChangedEventArgs : EventArgs
{
    public double Temperature { get; }

    public TemperatureChangedEventArgs(double temperature)
    {
        Temperature = temperature;
    }
}

public class TemperatureSensor
{
    private double _temperature;
    public event EventHandler TemperatureChanged;

    public void SetTemperature(double temperature)
    {
        _temperature = temperature;
        TemperatureChanged?.Invoke(this, new TemperatureChangedEventArgs(temperature));
    }
}

// Add Program class with Main method below
// Your code here

Hint

Subscribe to the event using += and a lambda expression. Use Console.WriteLine to print the temperature.

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