C# Interceptors, introduced in C# 12, offer a way to dynamically intercept method calls, injecting additional behaviour before or after the method execution without altering the original code. This is a powerful feature that enhances the flexibility and maintainability of your codebase, especially for cross-cutting concerns like logging, caching, transaction management, and security.

Why Interceptors?

Interceptors help in addressing common challenges in software development.

Separation of Concerns: By decoupling cross-cutting concerns from business logic.

DRY Principle: Avoiding repetition by centralizing the logic that would otherwise be scattered across multiple methods.

Flexibility: Providing a means to dynamically alter or extend method behaviour at runtime.

Please find below the steps to create Interceptors.

1. Enable Interceptors in Your Project - First, you need to enable the interceptors feature in your project by updating your .csproj file. As of now, Interceptors available in preview.

Open project file.csproj and add below code under PropertyGroup.

<PropertyGroup>
        <LangVersion>preview</LangVersion>
        <Features>InterceptorsPreview</Features>
</PropertyGroup>

2. Define an interface for the interceptor to standardize how interceptors should behave.

public interface IInterceptor
{
    void Intercept(IInvocation invocation);
}

3. Create a logging interceptor to demonstrate how interceptors can be used.

using System;
using System.Diagnostics;
using System.Linq;
 
public class LoggingInterceptor : IInterceptor
{
    public void Intercept(IInvocation invocation)
    {
        var method = invocation.Method.Name;
        var arguments = string.Join(", ", invocation.Arguments.Select(a => (a ?? "").ToString()));
       Console.WriteLine($"Calling method {method} with arguments: {arguments}");
 
        var stopwatch = Stopwatch.StartNew();
       invocation.Proceed(); // Proceed to the actual method
       stopwatch.Stop();
       Console.WriteLine($"Method {method} executed in {stopwatch.ElapsedMilliseconds} ms");
    }
}

4. To apply the interceptor, you'll need a proxy generator. Here’s an example using Castle DynamicProxy.

using Castle.DynamicProxy;
using System;
 
public class Program
{
    public static void Main()
    {
        var generator = new ProxyGenerator();
        var loggingInterceptor = new LoggingInterceptor();
        ICalculator calculator = generator.CreateInterfaceProxyWithTarget<ICalculator>(new Calculator(), loggingInterceptor);
 
        int result = calculator.Add(5, 10);
       Console.WriteLine($"Result: {result}");
    }
}
 
public interface ICalculator
{
    int Add(int a, int b);
}
 
public class Calculator : ICalculator
{
    public int Add(int a, int b)
    {
        return a + b;
    }
}

Please find below the real-world applications of Interceptors.

Logging: Track method calls, input parameters, and execution time. Centralize logging logic to avoid code clutter.

Caching: Cache the results of method calls to improve performance. Invalidate the cache based on certain conditions.

Security: Check user permissions before executing sensitive methods. Implement authentication and authorization checks.

Validation: Validate method input parameters before execution. Enforce business rules consistently.

Transaction Management: Start and commit transactions around method calls. Rollback transactions in case of errors.

Best Practices:

Granular Control: Use interceptors at the right granularity. Too many interceptors can lead to complexity and performance overhead.

Single Responsibility: Keep each interceptor focused on a single concern. For example, logging should be separate from validation.

Performance Considerations: Be mindful of the performance impact of interceptors. Heavy logging or complex validation can slow down your application.

Interceptors in C# 12 provide a powerful mechanism to manage cross-cutting concerns efficiently. By encapsulating these concerns within interceptors, you keep your business logic clean, maintainable, and focused. This modular approach not only adheres to best coding practices but also enhances the flexibility and scalability of your application.