ASP.NET Core–Use dynamic proxy with standard dependency injection

You don’t need to use a 3th party IoC container to use AOP(Aspect Oriented Programming) and the proxy pattern in ASP.NET Core. We’ll combine the power of Castle.DynamicProxy and the standard DI to make this possible.

Castle's dynamic proxies allows you to create proxies of abstract classes, interfaces and classes (only for virtual methods/properties).

Let’s create an example that caches the output of a repository call.

Here is the example repository that we want to proxy:

	public interface IProductRepository
	{
	IList<Product> GetAll();
	}

view raw IProductRepository.cs hosted with ❤ by GitHub

Now we first need to create an interceptor that intercepts the method calls and caches the response:

	public class CacheInterceptor : IInterceptor
	{
	private readonly IMemoryCache _cache;
	public CacheInterceptor(IMemoryCache cache)
	{
	_cache = cache;
	}
	public void Intercept(IInvocation invocation)
	{
	var name = $"{invocation.Method.DeclaringType}_{invocation.Method.Name}";
	var args = string.Join(", ", invocation.Arguments.Select(a => (a ?? "").ToString()));
	var cacheKey = $"{name}|{args}";
	if (!_cache.TryGetValue(cacheKey, out TResult returnValue))
	{
	invocation.Proceed();
	returnValue=invocation.ReturnValue as TResult;
	_cache.Set(cacheKey, returnValue);
	}
	return returnValue;
	}
	}

view raw CacheInterceptor.cs hosted with ❤ by GitHub

Let’s move on to the DI registration. We first need to create an extension method that triggers the proxy creation:

	public static class ServicesExtensions {
	public static void AddProxiedScoped<TInterface, TImplementation>(this IServiceCollection services)
	where TInterface : class
	where TImplementation : class, TInterface
	{
	services.AddScoped<TImplementation>();
	services.AddScoped(typeof(TInterface), serviceProvider =>
	{
	var proxyGenerator = serviceProvider.GetRequiredService<ProxyGenerator>();
	var actual = serviceProvider.GetRequiredService<TImplementation>();
	var interceptors = serviceProvider.GetServices<IInterceptor>().ToArray();
	return proxyGenerator.CreateInterfaceProxyWithTarget(typeof(TInterface), actual, interceptors);
	});
	}
	}

view raw ServicesExtensions.cs hosted with ❤ by GitHub

Almost there, as a last step we need to register everything:

	services.AddSingleton(new ProxyGenerator());
	services.AddScoped<IInterceptor, CacheInterceptor>();
	services.AddMemoryCache();
	services.AddProxiedScoped<IProductRepository, ProductRepository>();

view raw ServiceRegistration.cs hosted with ❤ by GitHub