A CacheAspect That Supports Async Method (Even Generics)

[bleesteady]

Hey guys. I struggled with this for some time, and I didn't see any great solutions to handle async methods with an "Around" Advice. But this seems to do the trick. I hope this helps somebody else out!

`[AspectInjector.Broker.Aspect(Scope.Global)]
[Injection(typeof(CacheAspect))]
public class CacheAspect : Attribute
{
private static IDistributedCache _cache;

/// <summary>
/// Time-to-live (TTL) for cache entries in seconds.
/// </summary>
public int TtlSeconds { get; set; } = 1800; // Default: 30 minutes

/// <summary>
/// Static method to initialize the cache dependency.
/// </summary>
public static void Initialize(IDistributedCache cache)
{
    _cache = cache ?? throw new ArgumentNullException(nameof(cache));
}

[Advice(Kind.Around, Targets = Target.Method)]
public object HandleMethod(
    [Argument(Source.Target)] Func<object[], object> target,
    [Argument(Source.Name)] string methodName,
    [Argument(Source.Arguments)] object[] args,
    [Argument(Source.Metadata)] MethodBase methodInfo)
{
    // Get the actual return type from the method metadata
    var returnType = (methodInfo as MethodInfo)?.ReturnType ?? typeof(object);

    // Determine if the method is asynchronous
    if (!typeof(Task).IsAssignableFrom(returnType)) return HandleSync(target, methodName, args);

    var taskType = returnType.IsGenericType ? returnType.GenericTypeArguments[0] : typeof(object);

    return HandleAsync(target, methodName, args, taskType);
}

private object HandleAsync(Func<object[], object> target, string methodName, IEnumerable args, Type returnType)
{
    // Dynamically create a Task<T> handler for the correct return type
    var genericHandleAsync = typeof(CacheAspect)
        .GetMethod(nameof(HandleAsyncTyped), BindingFlags.NonPublic | BindingFlags.Instance)
        .MakeGenericMethod(returnType);

    // Invoke the typed handler
    return genericHandleAsync.Invoke(this, new object[] { target, methodName, args });
}

private async Task<T> HandleAsyncTyped<T>(Func<object[], object> target, string methodName, object[] args)
{
    if (_cache == null)
        throw new InvalidOperationException("CacheAspect is not initialized. Call CacheAspect.Initialize first.");

    var cacheKey = GenerateCacheKey(methodName, args);

    // Try to retrieve cached data
    var cachedData = await _cache.GetStringAsync(cacheKey);
    if (!string.IsNullOrEmpty(cachedData))
    {
        return JsonSerializer.Deserialize<T>(cachedData);
    }

    // Execute the target method and await the result
    var taskResult = (Task<T>)target(args);
    var result = await taskResult.ConfigureAwait(false);

    // Cache the result
    var serializedData = JsonSerializer.Serialize(result);
    var cacheOptions = new DistributedCacheEntryOptions
    {
        AbsoluteExpirationRelativeToNow = TimeSpan.FromSeconds(TtlSeconds)
    };

    await _cache.SetStringAsync(cacheKey, serializedData, cacheOptions);

    return result;
}

private object HandleSync(Func<object[], object> target, string methodName, object[] args)
{
    if (_cache == null)
        throw new InvalidOperationException("CacheAspect is not initialized. Call CacheAspect.Initialize first.");

    var cacheKey = GenerateCacheKey(methodName, args);

    // Try retrieving the cached data
    var cachedData = _cache.GetString(cacheKey);
    if (!string.IsNullOrEmpty(cachedData))
    {
        var returnType = target.Method.ReturnType;
        return JsonSerializer.Deserialize(cachedData, returnType);
    }

    // Execute the target method
    var result = target(args);

    // Serialize and cache the result
    var serializedData = JsonSerializer.Serialize(result);
    var cacheOptions = new DistributedCacheEntryOptions
    {
        AbsoluteExpirationRelativeToNow = TimeSpan.FromSeconds(TtlSeconds)
    };

    _cache.SetString(cacheKey, serializedData, cacheOptions);

    return result;
}

private static string GenerateCacheKey(string methodName, object[] args)
{
    var argsKey = args is { Length: > 0 }
        ? string.Join("_", args)
        : "NoArgs";
    return $"{methodName}_{argsKey}";
}

}`