aaspnetcore开发框架中实现aop不仅仅在业务上，在代码的优雅简洁和架构的稳定上都有着至关重要。
下面介绍三种用过的。
第一种通过System.Reflection的DispatchProxy类来实现
首先新建一个aspnetcore项目
针对业务代码WarService加了一个代理的方法
public interface IWarService
{
string WipeOut();
IWarService Proxy(IWarService warService);
}
public class WarService : IWarService
{
public IWarService Proxy(IWarService warService)
{
return WarDispatch<IWarService>.Create(warService);
}
public string WipeOut()
{
return "us is over";
}
}
具体的WarDispatch就是核心代码了，继承自DispatchProxy。这里的before和after的实现就是针对实现了代码的service提前挖坑。
public class WarDispatch<T> : DispatchProxy where T : class
{
private T Target { get; set; }
public static T Create<T>(T target) where T : class
{
var proxy = Create<T, WarDispatch<T>>() as WarDispatch<T>;
proxy.Target = target;
return proxy as T;
}
protected override object? Invoke(MethodInfo? targetMethod, object?[]? args)
{
Before().Wait();
var result = targetMethod.Invoke(Target, args);
After().Wait();
return result;
}
Task Before()
{
return Task.CompletedTask;
}
Task After()
{
return Task.CompletedTask;
}
}
实现代码也相当简单
[ApiController]
[Route("[controller]")]
public class RescueEarthController : ControllerBase
{
private IWarService _warService;
public RescueEarthController(IWarService warService)
{
_warService = warService;
}
[HttpGet(Name = "AnnihilateHegemony")]
public string AnnihilateHegemony()
{
var proxy = _warService.Proxy(_warService); //代理
return proxy.WipeOut();
}
[HttpGet("two")]
public string AnnihilateHegemonyTwo()
{
return _warService.WipeOut();
}
}
当然不要忘了注入下服务类
builder.Services.AddScoped<IWarService, WarService>();
上面的方式是我自己想出来的，具体到项目中需要改进的地方应该还有很多，但是足够简单，功能也比较单一。
下面简单介绍下AspectCore.DynamicProxy现成组件的代理使用。
首先引用aspnetcore.extensions.dependencyinjection包
在program中使用动态代码
builder.Host.UseServiceProviderFactory(new DynamicProxyServiceProviderFactory());
builder.Services.ConfigureDynamicProxy(o =>{
//添加aop的配置
//该项目用attribute所以无需配置
});
内存的缓存代理
public class CacheDeleteInterceptorAttribute:AbstractInterceptorAttribute
{
private readonly Type[] _types;
private readonly string[] _methods;
public CacheDeleteInterceptorAttribute(Type[] types, string[] methods)
{
if (types.Length != methods.Length)
{
throw new Exception("Types必须跟Methods数量一致");
}
_types = types;
_methods = methods;
}
public override async Task Invoke(AspectContext context, AspectDelegate next)
{
var cache = context.ServiceProvider.GetService<MemoryCache>();
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.Remove(key);
}
}
}
public class CacheInterceptorAttribute : AbstractInterceptorAttribute
{
public override async Task Invoke(AspectContext context, AspectDelegate next)
{
bool isAsync = context.IsAsync();
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();
}
//string param = GetParaName(context.Parameters); //获取方法的参数名,
string key = $"Methods:{context.ImplementationMethod.DeclaringType.FullName}.{context.ImplementationMethod.Name}";//获取方法名称，也就是缓存key值
var cache = context.ServiceProvider.GetService<MemoryCache>(); //可以使用自定义的redis或者其他缓存
if (cache.Get(key) != null)
{
//反射获取缓存值
var value = typeof(MemoryCache).GetMethod("MemoryCache.Get").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))
{
//反射构建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();
//反射获取异步结果的值，相当于(context.ReturnValue as Task<>).Result
//returnValue = typeof(Task<>).MakeGenericType(returnType).GetProperty(nameof(Task<object>.Result)).GetValue(context.ReturnValue);
}
else
{
returnValue = context.ReturnValue;
}
cache.Set(key
//, param
, returnValue);
if(ExpireSeconds > 0)
{
cache.Set(key, TimeSpan.FromSeconds(ExpireSeconds));//设置key的过期时间
}
}
//private string GetParaName(object[] parameters)
//{
// throw new NotImplementedException();
//}
/// <summary>
/// 缓存秒数
/// </summary>
public int ExpireSeconds { get; set; }
}
dbcontext的代理
public class TransactionInterceptorAttribute : AbstractInterceptorAttribute
{
//public override async Task Invoke(AspectContext context, AspectDelegate next)
//{
// var dbcontext = context.ServiceProvider.GetService<CommonDbContext>();
// if (dbcontext.Database.CurrentTransaction != null)
// {
// await dbcontext.Database.BeginTransactionAsync();
// try
// {
// await next(context);
// await dbcontext.Database.CommitTransactionAsync();
// }catch(Exception ex)
// {
// await dbcontext.Database.RollbackTransactionAsync();
// throw ex;
// }
// }
// else
// {
// await next(context);
// }
//}//一个context
public override async Task Invoke(AspectContext context, AspectDelegate next)
{
var dbcontext = context.ServiceProvider.GetService<CommonDbContext>();
var dbcontextNext = context.ServiceProvider.GetService<NextDbContext>();
var transactionManager = dbcontext.Database.GetService<IDbContextTransactionManager>();
var transaction = await transactionManager.BeginTransactionAsync();
if (transaction != null)
{
await dbcontext.Database.BeginTransactionAsync();
try
{
await next(context);
await transaction.CommitAsync();
}
catch (Exception ex)
{
await transaction.RollbackAsync();
throw ex;
}
}
else
{
await next(context);
}
}//多个context
}
public class CommonDbContext:DbContext
{
public CommonDbContext(DbContextOptions<CommonDbContext> options):base(options)
{
}
}
public class NextDbContext : DbContext
{
public NextDbContext(DbContextOptions<CommonDbContext> options) : base(options)
{
}
}
使用就是这么简单
public class TestOperatorDbBusiness
{
[TransactionInterceptor]
public async ValueTask Add()
{
//TODO事务操作
}
}
上面的代理组件功能非常多，项目中需要自己去研究更多更全的用法。
上面代码的demo
exercisebook/AOP at main · liuzhixin405/exercisebook (github.com)
还有Castle.DynamicProxy，这个比较复杂一点。具体用法给个实例demo
exercisebook/AspNetCoreAOP at main · liuzhixin405/exercisebook (github.com)
总结：
一个aspnetcore中需要用到aop的地方非常多，框架自带的中间件，filter过滤器，efcore自带Interceptor都可以拿来用。
中间件例如mediator，这里面的拦截器也非常多，还有好多等待发掘。
当然自己也可以定义一些简单的中间层来做拦截。
相信多了解 在框架中有需要用的地方会事半功倍。
标签：Task,实现,aspnetcore,await,next,context,aop,var,public From： https://www.cnblogs.com/morec/p/17249940.html