.net5 AOP思想

.net5 AOP思想

划重点：AOP是一种思想

在.net core 中间件和过滤器都是AOP思想的实现，包括结构性设计模式种的装饰器模式都是实现AOP的方法

那AOP思想到底是啥？

AOP是OOP的延续，利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。(再通俗一点，就是不动原有业务逻辑的情况之下，在你之前和之后都能干点事情)

静态代理实现（装饰器模式实现AOP）

 public abstract class  IEat
    {
        public abstract void Eatfuc();

    }

 public class Eat : IEat
    {
        public override void Eatfuc()
        {
            Console.WriteLine("准备吃饭！");
        }
        public  void Xishoufuc()
        {
            Console.WriteLine("吃饭之前先洗手！");
        }
    }

比如说吃饭这件事情，定义一个吃饭的方法，但是呢，吃饭前先洗手，oop思想就是这样子的

 Eat eat = new Eat();
eat.Xishoufuc();//先洗手
eat.Eatfuc();//再吃饭

那如果说，我在吸收之前再做很多事情呢，势必，要在Eat 这个类里面加入很方法，然后前台一个一个调用，这样代码是相当的不稳定，而且还违背了设计模式的原则。

装饰器模式
在新建一个类，其实在前面就讲过，结构性设计模式的套路就是新建第三个类来解决问题。

 public class Eatzhuangshiqi : IEat
    {
        private IEat _Eat;
       public Eatzhuangshiqi(IEat Eat)
        {
            _Eat = Eat;
        }
        public override void Eatfuc()
        {
            Console.WriteLine("吃饭之前先洗手！");
            _Eat.Eatfuc();
        }
    }

前台调用

 //装饰器模式实现AOP
                IEat ea = new Eat();
                ea = new Eatzhuangshiqi(ea);
                ea.Eatfuc();

这样呢，前台不动，在有其他行为，我们只要再新建一个类，继续实现

委托实现AOP(在.net core中间件里面其实就是这玩意)

 public abstract class BaseAttribute: Attribute
    {
        public abstract Action fun(Action action, ApplyContext context);
      
    }

 public class InAction
    {
        [InAction1]
        [InAction2]
        public void Eat(ApplyContext context)
        {
            Console.WriteLine("核心方法");
        }
    }


    public class InAction1 : BaseAttribute
    {
       
        public override Action fun(Action action, ApplyContext context)
        {
           
            return new Action(() =>
            {
                {

                    action.Invoke();
                    Console.WriteLine("执行前");
                   
                    
                }
               
                //action.Invoke();
            });
          
        }
    }
    public class InAction2 : BaseAttribute
    {
        public InAction2()
        {

        }
        public override Action fun(Action action, ApplyContext context) {
            return new Action(() =>
            {
                {
                    action.Invoke();
                    Console.WriteLine("执行后");
                   
                }

            });
         
           
            
        }
     
    }

 public  class ActionAop
    {
        public static void Show()
        {
            ApplyContext context = new ApplyContext();
            InAction ia = new InAction();
            //定义一个委托，执行你要的业务逻辑方法（这里就是准备吃饭）;
          
            Type type = ia.GetType();//获取类
            MethodInfo methodInfo = type.GetMethod("Eat");
       
            object[] obj = new object[1];
            obj[0] = context;
             Action action = () => { methodInfo.Invoke(ia, obj); };//注意这边只是调用还没有执行方法，等到action.invoke才会真正开始执行

            
            if (methodInfo.IsDefined(typeof(InAction2), true))//遍历寻找特性
            {
                //未来了方便呢，这里农艺一个特性基类，，不然if判断比较多
                foreach (BaseAttribute attribute in methodInfo.GetCustomAttributes(typeof(BaseAttribute), true)) 
                {
                    action = attribute.fun(action, context);
                }
            }
            action.Invoke();
        }
    }

动态代理实现Aop