Events and Delegates in C#

In C#, events and delegates are key to creating flexible and responsive programs. Delegates, function similarly to method pointers, facilitating the calling of one method from another part of your code. Events employ delegates to inform other components of the program when an action occurs, such as a button being clicked. Utilizing events and delegates together enables the construction of programs that not only react to user interactions but also manage background tasks, thereby enhancing code organization and maintainability.

This blog will cover what events and delegates are, how to use them, where and when to apply them, and the pros and cons of using them in C#.

What are Delegates and Events?

In C#, delegates and events help one part of a program tell other parts when something happens. This makes it easy to keep everything in sync, so when one thing changes, other parts know and can respond right away.

Let’s see what is delegates?

Delegates is the Type Safe Function Pointer. (A type-safe function pointer let's you reference a method with a specific signature, ensuring correct parameter and return types in C#.)

A delegate, type-safe object that holds a reference to a method. It allows methods to be passed as parameters, making functions assignable dynamically at runtime.

Type safety is a critical feature in programming that ensures a delegate can only be assigned methods with compatible signatures, thereby preventing errors.

A delegate template in C# defines a specific method signature (parameter types and return type) without implementing the method.

public delegate ReturnType DelegateName(ParameterType1 parameter1, ParameterType2 parameter2, ...);

public delegate: Declares a delegate with specified access level.
ReturnType: The return type the delegate expects.
DelegateName: The name of the delegate type
(ParameterType1 parameter1, ParameterType2 parameter2, ...): Defines the expected parameter types and order, ensuring type safety.

let’s see what is event

Events in C# function as delegates with an added safety layer, allowing controlled method invocation.

An event is a type of delegate that controls who can trigger it. It let's other classes “subscribe” to receive updates from a main class, called the publisher. Only the publisher can start the event, while the other classes, known as subscribers, can only listen and respond. This setup ensures safe, one-way communication where subscribers get notified without being able to control the event.

Here’s a template for an event in C#:

public event DelegateType EventName;

public: Access modifier that controls the event's visibility.
event: Keyword indicating that this is an event.
DelegateType: The type of delegate used for the event. This can be a predefined delegate, likeEventHandler, or a custom delegate with a specific signature.
EventName: The name of the event, which should indicate its purpose or trigger.

Example with Custom Delegate

1
2

public delegate void CustomEventHandler(int value); // Define a custom delegate
public event CustomEventHandler OnValueChanged; // Declare an event using the custom delegate

This template guarantees that only methods matching the DelegateType signature can be attached to the event, ensuring controlled and type-safe handling of events.

How to Use Events and Delegates?

Using Delegates

To use delegates effectively:

Define the Delegate: Specify the method signature using the delegate keyword.
Create an Instance: Instantiate the delegate and assign it a method that matches the signature.
Invoke the Delegate: Invoke the delegate to call the assigned method.

For Example, using a delegate to perform various arithmetic operations

using System;
public class ArithmeticOperations
{
  // Define a delegate for arithmetic operations
  public delegate int Operation(int a, int b);

  // Method that accepts an Operation delegate as a parameter
  public int ExecuteOperation(int x, int y, Operation operation)
  {
    return operation(x, y); // Invokes the passed method
  }

  // Methods that match the Operation delegate signature
  public int Add(int a, int b)
  {
    return a + b;
  }
  public int Subtract(int a, int b)
  {
    return a - b;
  }
  public int Multiply(int a, int b)
  {
    return a * b;
  }
}

public class Program
{
  public static void Main()
  {
    ArithmeticOperations operations = new ArithmeticOperations();

    // Using the ExecuteOperation method with different operations
    int sum = operations.ExecuteOperation(5, 3, operations.Add);
    int difference = operations.ExecuteOperation(5, 3, operations.Subtract);
    int product = operations.ExecuteOperation(5, 3, operations.Multiply);

    // Displaying the results
    Console.WriteLine("Addition: " + sum);
    Console.WriteLine("Subtraction: " + difference);
    Console.WriteLine("Multiplication: " + product);
  }
}

Let’s understand example

Delegate Declaration: Operation is declared as a delegate that points to methods with two int parameters and an int return type.
Method Definitions:
- Arithmetic Methods: Add, Subtract, and Multiply are methods matching the Operation delegate signature, allowing them to be passed as parameters.
- ExecuteOperation Method: This method accepts two int values and an Operation delegate as parameters. It calls the delegate method passed to it with x and y as arguments.
Using ExecuteOperation: In Main, we call ExecuteOperation with different operations (Add, Subtract, Multiply) and print the results.

In the above example, delegates are used as function pointers to reference specific methods and to pass methods as parameters, allowing dynamic selection and execution of operations at runtime.

Using Events

To effectively use events:

Declare an Event: Declare an event with a delegate.
Subscribe: Another class can subscribe to this event using +=.
Raise the Event: Use Invoke to raise the event within the publisher.
Unsubscribe: Always unsubscribe when finished to avoid memory leaks.

Let’s build upon the delegate example from the arithmetic case by incorporating an event to alert subscribers each time an operation is executed.

using System;
public class ArithmeticOperations
{
  // Delegate declaration for arithmetic operations
  public delegate int Operation(int a, int b);

  // Event declaration using the Operation delegate
  public event Operation OnOperationPerformed;

  // Method that accepts an Operation delegate as a parameter and raises the event
  public int ExecuteOperation(int x, int y, Operation operation)
  {
    int result = operation(x, y); // Perform the operation
    OnOperationPerformed?.Invoke(x, y); // Raise the event to notify subscribers
    return result;
  }

  // Methods that match the Operation delegate signature
  public int Add(int a, int b) => a + b;
  public int Subtract(int a, int b) => a - b;
  public int Multiply(int a, int b) => a * b;
}

public class Program
{
  public static void Main()
  {
    ArithmeticOperations operations = new ArithmeticOperations();

    // Subscribe to the OnOperationPerformed event
    operations.OnOperationPerformed += (a, b) =>
    {
      Console.WriteLine("Operation performed with inputs " + a + " and " + b);
    };

    // Use ExecuteOperation to dynamically choose and execute an operation
    int sum = operations.ExecuteOperation(5, 3, operations.Add);
    int difference = operations.ExecuteOperation(5, 3, operations.Subtract);
    int product = operations.ExecuteOperation(5, 3, operations.Multiply);

    // Displaying the results
    Console.WriteLine("Addition Result: " + sum);
    Console.WriteLine("Subtraction Result: " + difference);
    Console.WriteLine("Multiplication Result: " + product);
  }
}

Let’s understand this example

ExecuteOperation Method:
- This method takes two numbers and an Operation delegate (e.g., Add, Subtract, or Multiply).
- It performs the operation and then raises the OnOperationPerformed event to notify any subscribers.
Event Subscription:
- In Main, we subscribe to OnOperationPerformed using a lambda function.
- This function prints a message whenever the event is triggered, showing the input values.
Performing Operations:
- We call ExecuteOperation with different operations (Add, Subtract, Multiply).
- Each time it’s called, OnOperationPerformed is triggered, notifying subscribers with the inputs used in the operation.

Here’s a simple example that demonstrates how an event works in C#

public class EventPublisher
{
  public event Action<string> ProcessCompleted;

  public void StartProcess()
  {
    Console.WriteLine("Process Started.");
    ProcessCompleted?.Invoke("Process Completed Successfully!");
  }
}

public class EventSubscriber
{
  public void OnProcessCompleted(string message)
  {
    Console.WriteLine(message);
  }
}

usage:

var publisher = new EventPublisher();
var subscriber = new EventSubscriber();

// Subscribe to the event
publisher.ProcessCompleted += subscriber.OnProcessCompleted;

// Start process and trigger event
publisher.StartProcess();

In this example, ProcessCompleted notifies EventSubscriber when StartProcess completes, without tightly coupling the classes.

When Should You Use Events and Delegates?

Events and delegates are most useful in these scenarios:

Decoupling Components (Loose Coupling): Ideal when you need communication between classes without introducing direct dependencies.
Callback Mechanisms: Delegates allow you to create flexible callback systems where a method is passed as a parameter and invoked later.
Asynchronous Notifications: Events work well for notifying subscribers about task completions or state changes in a responsive, event-driven way.
Publisher and Subscriber Patterns: In applications where publisher and subscriber scenarios are needed, these can be implemented using design patterns.

Where are Events and Delegates Used?

Most common usage as per below:

User Interface: Handle user actions like button clicks and form submissions.
Asynchronous Processing: Notify when background tasks, like file downloads or data loading, are complete.
Observer Pattern: Alert parts of an app about changes, e.g., stock price updates in a trading app.
Logging and Monitoring: Centralize logging, error tracking, or performance monitoring.
Game Development: Manage events like scoring, level completion, or character movements.
Data Binding: Sync changes between a model and UI for real-time updates.

Some more use case:

Plugin/Extension Systems:
- Example: In applications with plugins, use events to allow plugins to respond to core application events.
Data Validation and Business Rules:
- Example: Use delegates to pass custom validation functions into classes, allowing flexible and reusable data validation.
Observable Collections:
- Example: Use the ObservableCollection class in C#, which has a CollectionChanged event to notify listeners whenever items in the collection change. This is useful for real-time data updates in UI components.
Custom Event Notification:
- Example: Create a custom event to notify other parts of your application about specific changes or actions.
Asynchronous Task Completion:
- Example: Use events to notify the main thread when a background task is completed, such as data loading or file downloading. This keeps the UI responsive while handling asynchronous operations.

Advantages and Disadvantages of Events and Delegates

Pors

Loose Coupling: Enables independent communication between components for better modularity.
Encapsulation: Restricts event triggering to the owning class, ensuring safety.
Asynchronous Support: Ideal for interactive and responsive event-driven programming.
Reusability: Delegates allow dynamic method referencing, making code flexible and reusable.
Integration with Built-in Frameworks: C# frameworks like WPF, WinForms, and ASP.NET heavily rely on events, making them a natural fit for handling UI and other interactive scenarios.
Customizable Event Handling: Developers can define and handle custom events tailored to their specific application requirements.
Dynamic Behavior: Delegates allow methods to be assigned or changed at runtime, enabling dynamic behavior in your applications.

Cons

Memory Leaks: Failing to unsubscribe from events can cause memory leaks, as the event keeps a reference to the subscriber.
Debugging Challenges: Indirect control flow through events can make it harder to trace and identify the source of a call.
Performance Impact: Events and delegates add a minor performance overhead due to their abstraction layer.
Maintenance Issues: Excessive use of events can complicate code, making it harder to follow, debug, and maintain.

Conclusion

Events and delegates are powerful C# features that enhance modularity, responsiveness, and scalability, ideal for asynchronous programming, UI interactions, and observer patterns. Use them wisely to build robust, loosely coupled systems while avoiding pitfalls like memory leaks and debugging challenges.

Join Us & Grow Your Business

Create high-end software solutions for
your company withMoltech Solutions

Moltech Solutions Inc.

Jun, 25th 20258 min read

Services

Python Services

Know more about Python Development Services. We offer comprehensive solutions to build dynamic Machine Learning algorithms. Our team specializes in creating responsive and scalable applications.