/// <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);