AspectCore.Extensions.Autofac来实现AOP

之前实现AOP是采用Autofac.Extras.DynamicProxy这个库，Castle来实现Aop的，但是在异步方法中一直不知道怎么处理，后来在.NetCore下发现这个AspectCore来实现Aop的话对异步方法调用可以很好的处理。

安装AspectCore.Extensions.Autofac

然后通过Autofac注册 

            //注册AspectCore
            builder.RegisterDynamicProxy();

接下来就可以写自己方法的Aop了，只需继承AbstractInterceptorAttribute这个类

然后override重写Invoke方法

下面给出一个单据能否编辑的Aop

        public async override Task Invoke(AspectContext context, AspectDelegate next) {
            //判断是否是异步方法
            bool isAsync = context.IsAsync();
            bool IsExecute = true;
            ResponseMessageDTO msg = null;
            //获取参数
            var param = context.Parameters[0];
            //判断参数的类型
            if(param.GetType().Name== typeof(cw_ForecastApplyDto).Name) {
                var pam = param as cw_ForecastApplyDto;
                var currentMonth = _cw_ForecastMonthRepository.Where(b => b.OperateType == "Edit" && b.Status=="Y").FirstOrDefault();
                if (currentMonth == null) {
                    IsExecute = false;
                    msg = new ResponseMessageDTO() { Success = false, Message = "没有启动编辑预估月份，无法操作" };
                }
                else {
                    if (currentMonth.Month != pam.RunYearMonth) {
                        IsExecute = false;
                        msg = new ResponseMessageDTO() { Success = false, Message = "当前编辑的预估执行月份与系统设定不一致，无法操作" };
                    }
                    else {
                        //满足月份条件后判断 是否上月结转的数据无法修改 人员是否本人的单据
                        var forecast = _cw_ForecastApplyRepository.Where(b => b.DocID == pam.DocID).SingleOrDefault();
                        if (forecast != null) {
                            if (forecast.Source == "Carryover") {
                                IsExecute = false;
                                msg = new ResponseMessageDTO() { Success = false, Message = "当前预估为上月结转数据无法修改只能通过变更来操作，无法操作" };
                            }
                            //判断是否是本部门的预估
                            //...
                        }
                    }
                }
            }
            else {
                IsExecute = false;
                msg = new ResponseMessageDTO() { Success = false, Message = "参数类型错误" };
            }

            if (!IsExecute) {

                var returnType = context.ServiceMethod.ReturnType;//.GenericTypeArguments[0];
                var value = msg;

                //if (isAsync) {
                //    //取得异步返回的类型
                //    returnType = returnType.GenericTypeArguments.FirstOrDefault();
                //}

                if (isAsync) {
                    //取得异步返回的类型
                    returnType = returnType.GenericTypeArguments.FirstOrDefault();
                    //反射获取Task<>类型的返回值，相当于Task.FromResult(value)
                    context.ReturnValue = typeof(Task).GetMethod(nameof(Task.FromResult)).MakeGenericMethod(returnType).Invoke(null, new[] { value });
                }
                else {
                    context.ReturnValue = value;
                }
            }
            else {
                await context.Invoke(next);
            }
        }

关于如何使用这个Aop那就是在想要加Aop的方法加上次特性就行了，是不是使用起来很方便。