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

Yesterday I blogged about using Castle.DynamicProxy to generate a proxy class and use AOP techniques for caching. The code I showed worked for synchronous method calls but fails when you want to proxy async method calls.

Let’s see how we can get this working for async…

Here is the async version of our repository:

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

view raw IAsyncProductRepository hosted with ❤ by GitHub

We need an extra NuGet package:

dotnet add Castle.Core.AsyncInterceptor

Now we have to change our interceptor to call a second async interceptor:

	public class AsyncCacheInterceptor : AsyncInterceptorBase
	{
	private readonly IMemoryCache _cache;
	public AsyncCacheInterceptor(IMemoryCache cache)
	{
	_cache = cache;
	}
	protected override async Task InterceptAsync(IInvocation invocation, Func<IInvocation, Task> proceed)
	{
	//Nothing to cache here --> method that returns a task has no return value
	await proceed(invocation).ConfigureAwait(false);
	}
	protected override async Task<TResult> InterceptAsync<TResult>(IInvocation invocation, Func<IInvocation, Task<TResult>> proceed)
	{
	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))
	{
	returnValue = await proceed(invocation).ConfigureAwait(false);
	_cache.Set(cacheKey, returnValue);
	}
	return returnValue;
	}
	}

view raw AsyncCacheInterceptor.cs hosted with ❤ by GitHub

	public class CacheInterceptor : IInterceptor
	{
	private readonly AsyncCacheInterceptor _asyncInterceptor;
	public CacheInterceptor(AsyncCacheInterceptor asyncInterceptor)
	{
	_asyncInterceptor = asyncInterceptor;
	}
	public void Intercept(IInvocation invocation)
	{
	_asyncInterceptor.ToInterceptor().Intercept(invocation);
	}
	}

view raw CacheInterceptorUpdated.cs hosted with ❤ by GitHub

Our extension method that triggers the proxy creation remains the same:

	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

Our registration code should be extended to register the async interceptor as well:

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

view raw AsyncServiceRegistration.cs hosted with ❤ by GitHub