[C# Advanced] Dynamically Register Third-Party Library Events, Easily Done! Detailed Steps and Examples

Hello everyone, I'm the wolf at the end of the desert!

In C# development, we often need to handle various events, and sometimes we need to dynamically register events defined by third-party libraries. Today, I will share a demo on how to dynamically register third-party library events, with a detailed explanation of each step based on the provided code and comments. I hope this article helps you better understand how to dynamically register events, bringing more convenience to your development work.

In C#, events are special members that provide notifications of changes in the state of a class or object. Sometimes, when using third-party libraries, we need to dynamically register events defined by those libraries so that corresponding actions are executed when the events occur.

Below, we will demonstrate how to dynamically register third-party library events through a demo.

1. Preparation

First, we need a sample code for a third-party library. In this example, we have a library called ThirdLibrary, which contains a class named TestClass. This class defines several events and delegates, to which we will dynamically add handlers.

namespace ThirdLibrary;

public class TestClass
{
    /// <summary>
    /// Delegate with no parameters
    /// </summary>
    public Action? NoParamEvent;

    /// <summary>
    /// Delegate with one string parameter
    /// </summary>
    public Action<string>? OneParamEvent;

    /// <summary>
    /// Delegate with one basic type and one custom type parameter
    /// </summary>
    public Action<string, EventParam>? TwoParamEvent;

    /// <summary>
    /// EventHandler event
    /// </summary>
    public static event EventHandler<EventParam> EventHandlerEvent;

    public void CallEvent()
    {
        NoParamEvent?.Invoke();
        OneParamEvent?.Invoke("Single parameter delegate");
        TwoParamEvent?.Invoke("Two-parameter delegate invoked successfully", new EventParam() { Message = "Handsome, you invoked it successfully!" });
        EventHandlerEvent?.Invoke(this, new EventParam { Message = "EventHandler event invoked successfully" });
    }
}

/// <summary>
/// Custom type, needs to be received with dynamic when registering
/// </summary>
public class EventParam
{
    public string Message { get; set; }
}

2. Load the third-party library and create an instance

First, we use the Assembly.LoadFrom method to load the third-party library. Then, we use Assembly.GetType to get the type of TestClass, and Activator.CreateInstance to create an instance of it.

using System.Reflection;

// Load the third-party library  
var assembly = Assembly.LoadFrom("ThirdLibrary.dll");

// Create an instance of TestClass  
var testClassType = assembly.GetType("ThirdLibrary.TestClass");
var testClassInstance = Activator.CreateInstance(testClassType!);

3. Dynamically register events

Next, we will dynamically register events using reflection. First, we use Type.GetFields to get all fields of the TestClass type and find the corresponding event fields.

var fields = testClassType!.GetFields();

1. Register the parameterless delegate event

Find the NoParamEvent field by its name, and use FieldInfo.SetValue to assign the event handler method EventHandlerMethod to that field. Thus, when the NoParamEvent event is triggered, the EventHandlerMethod method will be called.

// 1. Get the NoParamEvent delegate  
var noParamEventField = fields.First(field => "NoParamEvent" == field.Name);
noParamEventField.SetValue(testClassInstance, EventHandlerMethod);

// NoParamEvent event handler method  
void EventHandlerMethod()
{
    Console.WriteLine("NoParamEvent: event raised.");
}

2. Register the delegate event with one string parameter

Similarly, find the OneParamEvent field and set it to the OneParamEventHandler method. This method accepts a string parameter and prints a message.

// 2. Get the OneParamEvent delegate and set the event parameter handler  
var oneParamEventField = fields.First(field => "OneParamEvent" == field.Name);
oneParamEventField.SetValue(testClassInstance, OneParamEventHandler);

// OneParamEvent event handler method, requires a string parameter  
void OneParamEventHandler(string param)
{
    Console.WriteLine($"OneParamEvent: event raised with parameter: {param}");
}

3. Register the delegate event with two parameters

For the TwoParamEvent field, we set it to the TwoParamEventHandler method. Since the second parameter is of custom type EventParam, we cannot know its exact type at compile time. Therefore, we use the dynamic keyword as the parameter type to resolve the type at runtime.

// 3. Get the TwoParamEvent delegate and set the event parameter handler  
var twoParamEventField = fields.First(field => "TwoParamEvent" == field.Name);
twoParamEventField.SetValue(testClassInstance, TwoParamEventHandler);

// TwoParamEvent event handler method, requires two parameters: string and EventParam type (passed via reflection, EventParam type is replaced with dynamic type)  
void TwoParamEventHandler(string param1, dynamic param2) // Use dynamic as the type of the second parameter and pass the actual parameter value via reflection  
{
    Console.WriteLine($"TwoParamEvent: event raised, param1={param1}, param2.Param1={param2.Message}");
}

4. Register the EventHandler event

For the EventHandlerEvent event, we use Type.GetEvents to get the event information and EventInfo.EventHandlerType to get the type of the event handler. Then, we create a delegate of type EventHandler<dynamic> and use Delegate.CreateDelegate to create a delegate instance that matches the event handler type. Finally, we use EventInfo.AddEventHandler to add the delegate instance to the event.

var events = testClassType.GetEvents();

// 4. Get the EventHandler event
var eventHandlerEventField = events.First(item => "EventHandlerEvent" == item.Name);
var eventHandlerType = eventHandlerEventField.EventHandlerType;
var eventHandlerMethod = new EventHandler<dynamic>(EventHandlerEventHandler);
var handle = Delegate.CreateDelegate(eventHandlerType, eventHandlerMethod.Method);
eventHandlerEventField.AddEventHandler(null, handle);

// EventHandler event handler method
void EventHandlerEventHandler(object sender, dynamic param)
{
    Console.WriteLine($"EventHandler: param.Param1={param.Message}");
}

4. Trigger events and verify registration

To verify that events are successfully registered, we call the CallEvent method of TestClass, which triggers all registered events. If everything is correct, we will see corresponding output messages on the console, proving that the event handlers are properly invoked.

ThirdLibrary library method:

/// <summary>
/// This method is used to trigger events for testing purposes
/// </summary>
public void CallEvent()
{
    NoParamEvent?.Invoke();
    OneParamEvent?.Invoke("Single parameter delegate");
    TwoParamEvent?.Invoke("Two-parameter delegate invoked successfully", new EventParam() { Message = "Handsome, you invoked it successfully!" });
    EventHandlerEvent?.Invoke(this, new EventParam { Message = "EventHandler event invoked successfully" });
}

Trigger the events above:

// 5. Simulate triggering event notification to test if events are registered successfully
var callEventMethod = testClassType.GetMethods().First(method => "CallEvent" == method.Name);
callEventMethod.Invoke(testClassInstance, null);

Program output:

NoParamEvent: event raised.
OneParamEvent: event raised with parameter: Single parameter delegate
TwoParamEvent: event raised, param1=Two-parameter delegate invoked successfully, param2.Param1=Handsome, you invoked it successfully!
EventHandler: param.Param1=EventHandler event invoked successfully

5. Summary

Through the steps above, we have successfully dynamically registered events defined by a third-party library. This approach is very useful when dealing with unpredictable or unmodifiable third-party libraries, as it allows us to dynamically add or remove event handlers at runtime.

I hope this article helps you better understand how to dynamically register third-party library events and apply this knowledge flexibly in actual development. If you have any questions or suggestions, feel free to leave a comment!