Using Dynamic Proxies to Implement Aspect-Oriented Programming in .NET 🧩✨

mostafa elsabbagh — Sun, 20 Apr 2025 09:44:46 +0000

Have you heard about Aspect-Oriented Programming?
Let's agree that Object-Oriented Programming doesn't always solve all our problems - there are other approaches.

Understanding Aspect-Oriented Programming (AOP) 🌟

Aspect-Oriented Programming is a programming paradigm that aims to increase modularity by allowing the separation of cross-cutting concerns. It does this by adding additional behavior to existing code without modifying the code itself.

Key Concepts in AOP 🔑

Before diving into implementation details, let's understand the fundamental concepts of AOP:

1. Cross-cutting Concerns ✂️

Cross-cutting concerns are aspects of a program that affect multiple parts of the system. Examples include:

✍️ Logging
🔒 Authorization
💱 Transaction Management
❌ Error Handling
🔍 Validation
📈 Performance Monitoring

These concerns typically "cut across" multiple components and can't be cleanly encapsulated in a single class or module using traditional OOP approaches.

2. Join Points 📍

A join point is a specific point during the execution of a program, such as method execution, exception handling, or field access. These are the points where aspect behavior can be inserted.
Example join points include:

📞 When a method is called
💥 When an exception is thrown
🏠 When a property is accessed

3. Pointcuts 🎯

A pointcut is a predicate that matches join points. It specifies where in the code the associated advice should be applied.
Examples of pointcuts:

🧩 All methods in the AccountService class
🔍 Any method that starts with "Get"
🏷️ Methods with a specific attribute like [Transactional]

4. Advice 💡

Advice is the action taken by an aspect at a particular join point. Types of advice include:

⏮️ Before: Executed before the join point
⏭️ After: Executed after the join point (regardless of outcome)
✅ After-returning: Executed after the join point completes successfully
⚠️ After-throwing: Executed if the join point throws an exception
🔄 Around: Surrounds the join point, providing control over whether the join point is executed

5. Aspects 🧩

An aspect is the combination of pointcuts and advice, encapsulating a cross-cutting concern.

The Problem AOP Solves ⚠️

Let's look at a typical method that's cluttered with cross-cutting concerns:

public void Deposit(string accountId, double amount)
{
    _logger.LogInformation($"Beginning deposit operation for account: {accountId}");

    // Authorization check
    if (!_securityService.HasAccess(GetCurrentUser(), accountId))
    {
        _logger.LogError("Unauthorized access attempt");
        throw new SecurityException("Unauthorized");
    }

    // Begin transaction
    using (var transaction = _dbContext.Database.BeginTransaction())
    {
        try
        {
            // Core deposit logic only
            var account = FindAccount(accountId);
            account.Balance += amount;
            UpdateAccount(account);

            // End transaction
            transaction.Commit();
            _logger.LogInformation("Deposit completed successfully");
        }
        catch (Exception ex)
        {
            transaction.Rollback();
            _logger.LogError($"Error occurred: {ex.Message}");
            throw;
        }
    }
}

As you can see there is a lot of code that doesn't involve our business logic. That doesn't mean we don't need that code but let's ask ourselves a question: what will we do for another function like withdrawal? Are we going to copy a lot of lines from the deposit logic?
Ideally, our core business logic should look like this:

public void Deposit(string accountId, double amount)
{
    // Only core logic 💼
    var account = FindAccount(accountId);
    account.Balance += amount;
    UpdateAccount(account);
}

Implementing AOP with Dynamic Proxies in .NET 🚀

While there are several ways to implement AOP, dynamic proxies provide a flexible, non-invasive approach that's well-suited for .NET applications.

What are Dynamic Proxies? 🎭

Dynamic proxies are objects created at runtime that implement the same interface as a target object but add additional behaviors when methods are called. They intercept method calls, allowing you to execute code before, after, or around the original method.

Castle DynamicProxy: A .NET Solution for AOP 🏰

Castle DynamicProxy is a popular library in the .NET ecosystem for implementing dynamic proxies. Here's how to use it:

Step 1: Set Up Your Core Service 📦

First, define your interface and implementation with clean business logic:

public interface IAccountService
{
    void Deposit(string accountId, double amount);
    void Withdraw(string accountId, double amount);
    Account GetAccountDetails(string accountId);
}

public class AccountService : IAccountService
{
    private readonly DbContext _dbContext;

    public AccountService(DbContext dbContext)
    {
        _dbContext = dbContext;
    }

    public void Deposit(string accountId, double amount)
    {
        // Only core logic! 💼
        var account = FindAccount(accountId);
        account.Balance += amount;
        UpdateAccount(account);
    }

    public void Withdraw(string accountId, double amount)
    {
        // Only core logic! 💼
        var account = FindAccount(accountId);
        if (account.Balance >= amount)
        {
            account.Balance -= amount;
            UpdateAccount(account);
        }
        else
        {
            throw new InsufficientFundsException("Not enough balance");
        }
    }

    public Account GetAccountDetails(string accountId)
    {
        return FindAccount(accountId);
    }

    private Account FindAccount(string accountId)
    {
        return _dbContext.Accounts.Find(accountId);
    }

    private void UpdateAccount(Account account)
    {
        _dbContext.SaveChanges();
    }
}

Step 2: Create Interceptors for Your Aspects 🔄

Interceptors in Castle DynamicProxy represent the advice in AOP:

// Logging aspect (advice) ✍️
public class LoggingInterceptor : IInterceptor
{
    private readonly ILogger _logger;

    public LoggingInterceptor(ILogger logger)
    {
        _logger = logger;
    }

    public void Intercept(IInvocation invocation)
    {
        var methodName = invocation.Method.Name;

        // Before advice ⏮️
        _logger.LogInformation($"Starting method: {methodName}");

        try
        {
            // Proceed to the original method (like "around" advice 🔄)
            invocation.Proceed();

            // After-returning advice ✅
            _logger.LogInformation($"Successfully completed method: {methodName}");
        }
        catch (Exception ex)
        {
            // After-throwing advice ⚠️
            _logger.LogError($"Exception in method {methodName}: {ex.Message}");
            throw;
        }
    }
}

// Security aspect (advice) 🔒
public class SecurityInterceptor : IInterceptor
{
    private readonly ISecurityService _securityService;

    public SecurityInterceptor(ISecurityService securityService)
    {
        _securityService = securityService;
    }

    public void Intercept(IInvocation invocation)
    {
        // Before advice with conditional execution ⏮️
        if (invocation.Method.Name is "Deposit" or "Withdraw" or "GetAccountDetails")
        {
            var accountId = (string)invocation.Arguments[0];
            if (!_securityService.HasAccess(GetCurrentUser(), accountId))
            {
                throw new SecurityException("Unauthorized");
            }
        }

        // Proceed to the original method
        invocation.Proceed();
    }

    private string GetCurrentUser() => Thread.CurrentPrincipal?.Identity?.Name;
}

// Transaction aspect (advice) 💱
public class TransactionInterceptor : IInterceptor
{
    private readonly DbContext _dbContext;

    public TransactionInterceptor(DbContext dbContext)
    {
        _dbContext = dbContext;
    }

    public void Intercept(IInvocation invocation)
    {
        // Pointcut condition - only apply to methods that modify data 🎯
        if (invocation.Method.Name is "Deposit" or "Withdraw")
        {
            // Around advice with transaction handling 🔄
            using var transaction = _dbContext.Database.BeginTransaction();
            try
            {
                invocation.Proceed();
                transaction.Commit();
            }
            catch
            {
                transaction.Rollback();
                throw;
            }
        }
        else
        {
            // For read-only operations, just proceed
            invocation.Proceed();
        }
    }
}

Step 3: Apply the Aspects Using Dynamic Proxy 🎭

Now, we can create a dynamic proxy that applies our aspects to the service:

// Install the package: dotnet add package Castle.Core 📦

// Create a proxy generator 🏭
var generator = new ProxyGenerator();

// Create the target service 🎯
var accountService = new AccountService(dbContext);

// Create interceptors (aspects) 🧩
var loggingInterceptor = new LoggingInterceptor(logger);
var securityInterceptor = new SecurityInterceptor(securityService);
var transactionInterceptor = new TransactionInterceptor(dbContext);

// Create a proxy with all interceptors 🎭
IAccountService proxy = generator.CreateInterfaceProxyWithTarget<IAccountService>(
    accountService,
    loggingInterceptor,
    securityInterceptor,
    transactionInterceptor
);

// Use the proxy as if it were the real service 🚀
proxy.Deposit("123", 100.00);

Step 4: Integrate with Dependency Injection 💉

In a real application, you'd register your services with the DI container:

public void ConfigureServices(IServiceCollection services)
{
    // Register your DbContext 📝
    services.AddDbContext<AppDbContext>();

    // Register the real service 💼
    services.AddScoped<AccountService>();

    // Register interceptors (aspects) 🧩
    services.AddSingleton<LoggingInterceptor>();
    services.AddSingleton<SecurityInterceptor>();
    services.AddSingleton<TransactionInterceptor>();

    // Register the proxy generator 🏭
    services.AddSingleton<ProxyGenerator>();

    // Register the proxied service as the implementation of the interface 🎭
    services.AddScoped<IAccountService>(provider =>
    {
        var generator = provider.GetRequiredService<ProxyGenerator>();
        var target = provider.GetRequiredService<AccountService>();

        return generator.CreateInterfaceProxyWithTarget<IAccountService>(
            target,
            provider.GetRequiredService<LoggingInterceptor>(),
            provider.GetRequiredService<SecurityInterceptor>(),
            provider.GetRequiredService<TransactionInterceptor>()
        );
    });
}

Advanced AOP Techniques with Dynamic Proxies 🚀

Using Attributes for Pointcuts 🏷️

Attributes can define more declarative pointcuts:

[AttributeUsage(AttributeTargets.Method)]
public class TransactionalAttribute : Attribute { } 💱

[AttributeUsage(AttributeTargets.Method)]
public class LoggedAttribute : Attribute { } ✍️

public interface IAccountService
{
    [Transactional] 💱
    [Logged] ✍️
    void Deposit(string accountId, double amount);

    [Transactional] 💱
    [Logged] ✍️
    void Withdraw(string accountId, double amount);

    [Logged] ✍️
    Account GetAccountDetails(string accountId);
}

// Then create interceptors that respect these attributes 🧩
public class AttributeBasedTransactionInterceptor : IInterceptor
{
    private readonly DbContext _dbContext;

    public AttributeBasedTransactionInterceptor(DbContext dbContext)
    {
        _dbContext = dbContext;
    }

    public void Intercept(IInvocation invocation)
    {
        // Pointcut: methods with the Transactional attribute 🎯
        var hasTransactionalAttribute = invocation.Method
            .GetCustomAttributes(typeof(TransactionalAttribute), true)
            .Any();

        if (hasTransactionalAttribute)
        {
            using var transaction = _dbContext.Database.BeginTransaction();
            try
            {
                invocation.Proceed();
                transaction.Commit();
            }
            catch
            {
                transaction.Rollback();
                throw;
            }
        }
        else
        {
            invocation.Proceed();
        }
    }
}

Creating Custom Interceptor Selectors 🔍

For more complex pointcut definitions:

public class CustomInterceptorSelector : IInterceptorSelector
{
    public IInterceptor[] SelectInterceptors(Type type, MethodInfo method, IInterceptor[] interceptors)
    {
        var result = new List<IInterceptor>();

        // Select based on method characteristics 🎯
        if (method.Name.StartsWith("Get"))
        {
            // For read operations, only apply logging and security 📚
            result.AddRange(interceptors.Where(i => 
                i is LoggingInterceptor || i is SecurityInterceptor));
        }
        else
        {
            // For write operations, apply all interceptors ✏️
            result.AddRange(interceptors);
        }

        return result.ToArray();
    }
}

// Use the selector when creating the proxy 🎭
var options = new ProxyGenerationOptions { Selector = new CustomInterceptorSelector() };
var proxy = generator.CreateInterfaceProxyWithTarget<IAccountService>(
    target, 
    options,
    interceptors
);

Benefits of AOP with Dynamic Proxies 🌟

Separation of Concerns 🧩: Business logic is cleanly separated from cross-cutting concerns.
Code Reusability ♻️: Aspects can be reused across multiple services.
Single Responsibility Principle 🎯: Each class has a single responsibility.
Maintainability 🔧: Changes to cross-cutting concerns require updates in only one place.
Testability 🧪: Business logic can be tested in isolation without cross-cutting concerns.

Limitations and Considerations ⚠️

Performance Overhead ⏱️: There's a small performance cost for method interception.
Debugging Complexity 🐛: It can be harder to debug when issues occur within interceptors.
Magic Factor 🔮: The behavior isn't immediately visible in the source code.
Interface Requirement 📋: Works best with interfaces rather than concrete classes.

Alternatives to Dynamic Proxies in .NET 🔄

While dynamic proxies are powerful, other AOP approaches in .NET include:

Decorator Pattern 🎁: Similar to proxies but implemented manually for more control.
Source Generators ⚙️: Generate aspects at compile-time for better performance.
PostSharp 📌: Commercial library that weaves aspects into IL code at compile time.
ASP.NET Core Middleware/Filters 🔍: For web-specific concerns.

Conclusion 🏁

Aspect-Oriented Programming provides a powerful paradigm for handling cross-cutting concerns, and dynamic proxies offer a flexible, runtime approach to implementing AOP in .NET applications.
By using Castle DynamicProxy, you can keep your business logic clean and focused while applying aspects like logging, security, and transaction management without modifying the original code. This leads to more maintainable, modular applications that better adhere to the single responsibility principle.
Whether you're building a new application or improving an existing one, consider how AOP with dynamic proxies might help you create cleaner, more maintainable code. 🚀

Forem: mostafa elsabbagh