（.net core 3.1）详解C#委托（二）--委托+特性 实现AOP思想（俄罗斯套娃的实现）

（.net core 3.1）详解C#委托（二）–委托+特性 实现AOP思想（俄罗斯套娃的实现）

1.之前呢讲了委托的基础，归结一句话，就是呢，委托就是把方法当做参数使用，继续呢往下面传递。

2.委托的本质呢其实就是一个类

上一个例子（一个主要的方法呢，在上面加上一个特性呢，实现方法执行之前呢，先执行呢，特性里面的东西并且呢，可以扩展）
第一步，先建立一个抽象特性基类

 public abstract class BaseAttribute : Attribute
    {
        public abstract Action Do(Action action);

    }

第二步呢，建立一个类，写个方法，

 public class CoreAction
    {
        [Befor]
        public void Methond()
        {
            Console.WriteLine("主要执行的方法"); 
        }


    }

第三部呢，建立个特性类继承自呢特性基类

  public class BeforAttribute : BaseAttribute
    {
        public override Action Do(Action action)
        {
            Console.WriteLine("执行之前基础操作！");
            Action acc = new Action(() =>
            {
                action.Invoke();
            });
            return acc;
        }
    }

第四部呢，我们建立一个类，来实现操作

public class DelegateExtension
    {

        public void Show()
        {
            CoreAction ca = new CoreAction();
           
            Type type = ca.GetType();
            MethodInfo methodInfo = type.GetMethod("Methond");
            Action action = () => { methodInfo.Invoke(ca, null); };
            if (methodInfo.IsDefined(typeof(BeforAttribute),true))
            {
                foreach (BaseAttribute ba in methodInfo.GetCustomAttributes(typeof(BaseAttribute),true))
                {
                    action = ba.Do(action);
                }
            }
            action.Invoke();
        }


    }

代码讲解：
CoreAction ca = new CoreAction(); 这里呢就直接new对象了创建实例了，也可以呢使用反射来创建实例，减少依赖的话，可以选择反射。
**MethodInfo methodInfo = type.GetMethod(“Methond”)：**这个是得到我们核心代码，就是我们真正的业务逻辑。
**Action action = () => { methodInfo.Invoke(ca, null); };**这个呢就是是一个lambad表达式，其实就是个委托，就是执行呢上面实力出来的方法，等同于呢ca .show()

**methodInfo.IsDefined(typeof(BeforAttribute),true)**判断这个方法上面是否有呢，这个BeforAttribute特性，有的话，直接调用自定义特性方法BaseAttribute ba in methodInfo.GetCustomAttributes(typeof(BaseAttribute),true).这里面的true是继承的属性，是否呢特性继承也给他找出来，最后直接执行。。

讲解一下执行过程，注意，定义了委托Action，只有在Invoke（）的时候才会执行。
Action action = () => { methodInfo.Invoke(ca, null); };这是定义的
action = ba.Do(action);这是特性类里面的方法执行过后返回的委托，然后呢将定义的额委托以参数的形式传入到该方法 action = ba.Do(action);

 public override Action Do(Action action)
        {
            Console.WriteLine("执行之前基础操作！");
            Action acc = new Action(() =>
            {
                action.Invoke();
            });
            return acc;
        }

最后执行的时候呢，其实是在

Console.WriteLine(“执行之前基础操作！”);
Action acc = new Action(() =>
{
action.Invoke();
});
return acc;
这个 action.Invoke();先执行，这个先执行呢，不就先执行了do里面的扩展方法呢吗，一个包围一个的