/// <summary> /// 执行前置拦截器 /// </summary> /// <param name="invocation"></param> private async Task <Tuple <List <AspectPointAttribute>, List <AspectInvokeAttribute>, Exception> > BeforeInterceptAttribute(IInvocation invocation) { //先从缓存里面拿到这个方法时候打了继承AspectInvokeAttribute的标签 if (!_cache.CacheList.TryGetValue(invocation.MethodInvocationTarget, out var Attributes) || Attributes == null || !Attributes.Any()) { //动态泛型类 if (!invocation.MethodInvocationTarget.DeclaringType.GetTypeInfo().IsGenericType || (!_cache.DynamicCacheList.TryGetValue(invocation.MethodInvocationTarget.GetMethodInfoUniqueName(), out var AttributesDynamic) || AttributesDynamic == null || !AttributesDynamic.Any())) { return(null); } Attributes = AttributesDynamic; } var aspectContext = new AspectContext(_component, invocation); Exception ex = null; try { foreach (var attribute in Attributes) { //如果一个方法上面既有AspectAroundAttribute 又有 AspectBeforeAttribute 的话 按照下面的优先级 抛弃 AspectBeforeAttribute switch (attribute) { case AspectAroundAttribute aspectAroundAttribute: await aspectAroundAttribute.Before(aspectContext); break; case AspectBeforeAttribute aspectBeforeAttribute: await aspectBeforeAttribute.Before(aspectContext); break; } } } catch (Exception e) { ex = e; } return(new Tuple <List <AspectPointAttribute>, List <AspectInvokeAttribute>, Exception>(Attributes.OfType <AspectPointAttribute>().ToList(), Attributes, ex)); }
private async Task AfterInterceptAttribute(List <AspectInvokeAttribute> Attributes, IInvocation invocation, Exception exp) { var aspectContext = new AspectContext(_component, invocation, exp); foreach (var attribute in Attributes) { switch (attribute) { case AspectAroundAttribute aspectAroundAttribute: await aspectAroundAttribute.After(aspectContext); break; case AspectAfterAttribute aspectAfterAttribute: await aspectAfterAttribute.After(aspectContext); break; } } }
/// <summary> /// 有返回值拦截器 /// </summary> /// <typeparam name="TResult"></typeparam> /// <param name="invocation"></param> /// <param name="proceedInfo"></param> /// <param name="proceed"></param> /// <returns></returns> protected override async Task <TResult> InterceptAsync <TResult>(IInvocation invocation, IInvocationProceedInfo proceedInfo, Func <IInvocation, IInvocationProceedInfo, Task <TResult> > proceed) { var attribute = await BeforeInterceptAttribute(invocation); try { TResult r; if (attribute == null) { r = await proceed(invocation, proceedInfo); return(r); } if (attribute.Item3 != null) { await AfterInterceptAttribute(attribute.Item2, invocation, attribute.Item3); throw attribute.Item3; } if (attribute.Item1 == null || !attribute.Item1.Any()) { r = await proceed(invocation, proceedInfo); } else { AspectMiddlewareBuilder builder = new AspectMiddlewareBuilder(); foreach (var pointAspect in attribute.Item1) { builder.Use(next => async ctx => { await pointAspect.OnInvocation(ctx, next); //如果有拦截器设置 ReturnValue 那么就直接拿这个作为整个拦截器的方法返回值 if (ctx.InvocationContext.ReturnValue != null) { ctx.Result = ctx.InvocationContext.ReturnValue; } }); } builder.Use(next => async ctx => { ctx.Result = await proceed(invocation, proceedInfo); invocation.ReturnValue = ctx.Result; //原方法的执行返回值 }); var aspectfunc = builder.Build(); var aspectContext = new AspectContext(_component, invocation); await aspectfunc(aspectContext); r = (TResult)aspectContext.Result; } await AfterInterceptAttribute(attribute.Item2, invocation, null); return(r); } catch (Exception e) { if (attribute != null) { await AfterInterceptAttribute(attribute.Item2, invocation, e); } throw; } }
/// <summary> /// 后置执行 /// </summary> /// <param name="aspectContext"></param> public abstract Task After(AspectContext aspectContext);
/// <summary> /// 前置执行 /// </summary> /// <param name="aspectContext"></param> public abstract Task Before(AspectContext aspectContext);
/// <summary> /// 拦截器 /// </summary> /// <param name="aspectContext">拦截上下文</param> /// <param name="_next">下一个拦截器 最后一个是执行被拦截的方法</param> /// <returns></returns> public abstract Task OnInvocation(AspectContext aspectContext, AspectDelegate _next);