How to use DispatchProxy in C#

The DispatchProxy class is a useful tool for implementing AOP by dynamically intercepting method calls in a proxy object.

Understanding Cross-Cutting Concerns

Cross-cutting concerns are issues that affect multiple parts of an application, like logging or performance monitoring. These concerns can clutter the core business logic, but AOP allows them to be separated, resulting in cleaner and more maintainable code. AOP modularizes these concerns, so they can be handled in one central place and applied wherever needed.

The DispatchProxy Class in C#

The DispatchProxy class is a key component for implementing AOP in C#. It helps intercept method calls using dynamic proxies, enabling you to inject additional logic, such as logging, without modifying the underlying business logic. The class is abstract and part of the System.Reflection namespace, containing methods like Create<T>() and Invoke() for proxy creation and method interception, respectively.

protected abstract object Invoke(MethodInfo targetMethod, object[] args);
public static T Create<T>() where T : DispatchProxy;

Creating a Proxy with DispatchProxy

Let’s create an example where we use DispatchProxy to intercept method calls in an interface and its implementation.

interface INotificationService
{
    void SendNotification(string message);
}

class NotificationService : INotificationService
{
    public void SendNotification(string message)
    {
        Console.WriteLine($"Notification sent: {message}");
    }
}

Next, we’ll implement a proxy class that intercepts method calls to this service:

class NotificationServiceProxy : DispatchProxy, INotificationService
{
    private INotificationService _target;

    protected override object Invoke(MethodInfo targetMethod, object[] args)
    {
        Console.WriteLine($"Intercepted method: {targetMethod.Name}");
        var result = targetMethod.Invoke(_target, args);
        Console.WriteLine($"Method {targetMethod.Name} executed.");
        return result;
    }

    public static T CreateProxy<T>(T target) where T : class
    {
        var proxy = Create<T>() as NotificationServiceProxy;
        proxy._target = target;
        return proxy as T;
    }
}

With this proxy in place, any method invoked on the proxy will be intercepted:

INotificationService service = NotificationServiceProxy.CreateProxy(new NotificationService());
service.SendNotification("Hello, world!");

This will output:

Intercepted method: SendNotification
Notification sent: Hello, world!
Method SendNotification executed.

Adding Error Handling with DispatchProxy

Now, let’s extend the proxy to include error handling. Imagine you want to log errors when methods fail. You can modify the NotificationServiceProxy to handle exceptions:

public class ErrorHandlingProxy : DispatchProxy
{
    private object _target;

    protected override object Invoke(MethodInfo targetMethod, object[] args)
    {
        try
        {
            Console.WriteLine($"Invoking method: {targetMethod.Name}");
            return targetMethod.Invoke(_target, args);
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error in method {targetMethod.Name}: {ex.Message}");
            throw;
        }
    }

    public static T Create<T>(T target) where T : class
    {
        var proxy = Create<T>() as ErrorHandlingProxy;
        proxy._target = target;
        return proxy as T;
    }
}

In this example, if an exception occurs in any method, the proxy catches it and logs an error message:

public class NotificationServiceWithError : INotificationService
{
    public void SendNotification(string message)
    {
        if (string.IsNullOrEmpty(message))
            throw new ArgumentException("Message cannot be empty");
        Console.WriteLine($"Notification sent: {message}");
    }
}

var serviceWithError = ErrorHandlingProxy.Create(new NotificationServiceWithError());
serviceWithError.SendNotification("");  // This will throw an error and log it

Output:

Invoking method: SendNotification
Error in method SendNotification: Message cannot be empty

The DispatchProxy class in C# is a powerful feature for implementing AOP, helping to separate concerns like logging and error handling from core business logic. By creating proxies, you can intercept method calls at runtime, inject custom behavior, and keep your application code clean and maintainable.