public class Program
  {
    public static void Main(string[] args)
    {
      CreateHostBuilder(args).Build().Run();
    }

    public static IHostBuilder CreateHostBuilder(string[] args) =>
      Host.CreateDefaultBuilder(args)
      .ConfigureWebHostDefaults(webBuilder =>
      {
        webBuilder.UseStartup<Startup>();
      })
      //用AspectCore替換默認的IOC容器
      .UseServiceProviderFactory(new DynamicProxyServiceProviderFactory());
}

services.ConfigureDynamicProxy(o=> { 
   //添加AOP的配置
});

services.AddControllers()
//把控制器當成服務(wù)
.AddControllersAsServices()

public class TransactionInterceptorAttribute : AbstractInterceptorAttribute
  {
    public async override Task Invoke(AspectContext context, AspectDelegate next)
    {
      var dbContext = context.ServiceProvider.GetService<AppDbContext>();
      //先判斷是否已經(jīng)啟用了事務(wù)
      if (dbContext.Database.CurrentTransaction == null)
      {
        await dbContext.Database.BeginTransactionAsync();
        try
        {
          await next(context);
          dbContext.Database.CommitTransaction();
        }
        catch (Exception ex)
        {
          dbContext.Database.RollbackTransaction();
          throw ex;
        }
      }
      else
      {
        await next(context);
      }
    }
  }

public class CacheInterceptorAttribute : AbstractInterceptorAttribute
  {
    /// <summary>
    /// 緩存秒數(shù)
    /// </summary>
    public int ExpireSeconds { get; set; }

    public async override Task Invoke(AspectContext context, AspectDelegate next)
    {
      //判斷是否是異步方法
      bool isAsync = context.IsAsync();
      //if (context.ImplementationMethod.GetCustomAttribute(typeof(AsyncStateMachineAttribute)) != null)
      //{
      //  isAsync = true;
      //}
      //先判斷方法是否有返回值，無就不進行緩存判斷
      var methodReturnType = context.GetReturnParameter().Type;
      if (methodReturnType == typeof(void) || methodReturnType == typeof(Task) || methodReturnType == typeof(ValueTask))
      {
        await next(context);
        return;
      }
      var returnType = methodReturnType;
      if (isAsync)
      {
        //取得異步返回的類型
        returnType = returnType.GenericTypeArguments.FirstOrDefault();
      }
      //獲取方法參數(shù)名
      string param = CommonHelper.ObjectToJsonString(context.Parameters);
      //獲取方法名稱，也就是緩存key值
      string key = "Methods:" + context.ImplementationMethod.DeclaringType.FullName + "." + context.ImplementationMethod.Name;
      var cache = context.ServiceProvider.GetService<ICacheHelper>();
      //如果緩存有值，那就直接返回緩存值
      if (cache.HashExists(key, param))
      {
        //反射獲取緩存值，相當于cache.HashGet<>(key,param)
        var value = typeof(ICacheHelper).GetMethod(nameof(ICacheHelper.HashGet)).MakeGenericMethod(returnType).Invoke(cache, new[] { key, param });
        if (isAsync)
        {
          //判斷是Task還是ValueTask
          if (methodReturnType == typeof(Task<>).MakeGenericType(returnType))
          {
            //反射獲取Task<>類型的返回值，相當于Task.FromResult(value)
            context.ReturnValue = typeof(Task).GetMethod(nameof(Task.FromResult)).MakeGenericMethod(returnType).Invoke(null, new[] { value });
          }
          else if (methodReturnType == typeof(ValueTask<>).MakeGenericType(returnType))
          {
            //反射構(gòu)建ValueTask<>類型的返回值，相當于new ValueTask(value)
            context.ReturnValue = Activator.CreateInstance(typeof(ValueTask<>).MakeGenericType(returnType), value);
          }
        }
        else
        {
          context.ReturnValue = value;
        }
        return;
      }
      await next(context);
      object returnValue;
      if (isAsync)
      {
        returnValue = await context.UnwrapAsyncReturnValue();
        //反射獲取異步結(jié)果的值，相當于(context.ReturnValue as Task<>).Result
        //returnValue = typeof(Task<>).MakeGenericType(returnType).GetProperty(nameof(Task<object>.Result)).GetValue(context.ReturnValue);

      }
      else
      {
        returnValue = context.ReturnValue;
      }
      cache.HashSet(key, param, returnValue);
      if (ExpireSeconds > 0)
      {
        cache.SetExpire(key, TimeSpan.FromSeconds(ExpireSeconds));
      }

    }
  }

public class CacheDeleteInterceptorAttribute : AbstractInterceptorAttribute
{
  private readonly Type[] _types;
  private readonly string[] _methods;

  /// <summary>
  /// 需傳入相同數(shù)量的Types跟Methods，同樣位置的Type跟Method會組合成一個緩存key，進行刪除
  /// </summary>
  /// <param name="Types">傳入要刪除緩存的類</param>
  /// <param name="Methods">傳入要刪除緩存的方法名稱，必須與Types數(shù)組對應(yīng)</param>
  public CacheDeleteInterceptorAttribute(Type[] Types, string[] Methods)
  {
    if (Types.Length != Methods.Length)
    {
      throw new ApiFailException(ApiFailCode.OPERATION_FAIL, "Types必須跟Methods數(shù)量一致");
    }
    _types = Types;
    _methods = Methods;
  }

  public async override Task Invoke(AspectContext context, AspectDelegate next)
  {
    var cache = context.ServiceProvider.GetService<ICacheHelper>();
    await next(context);
    for (int i = 0; i < _types.Length; i++)
    {
      var type = _types[i];
      var method = _methods[i];
      string key = "Methods:" + type.FullName + "." + method;
      cache.Delete(key);
    }
  }
}