SourceGenerator 使用姿势（1）：生成代理类，实现简单的AOP

SourceGenerator 已经出来很久了，也一直在关注。之前观摩大佬 xljiulang 的 WebApiClient 使用 SourceGenerator 生成接口代理类，深受启发，准备拿过来用看看（发出白嫖的声音），写个编译期静态代理AOP。本篇重点是怎么获取元数据，得到想要的数据，生成想要的代码（往下拖到第 4 点）。

几个月前写了个demo，现在趁着有空重新整理完善了下。.net 6 新增了个 IIncrementalGenerator 进行增量编译，这个还没研究，后面再说。

我的思路是继承，生成一个类去继承需要拦截的实际类，然后重写相关的方法，此时插入额外的方法，比如 Before，After 等。这就要求相关方法必须是 可重写 的， virtual 或 override。好了，开干。

1、定义Aop属性，打个标签，SourceGenerator 根据这个标签查找相关的 class 或 interface

    /// <summary>
    /// Aop 拦截器
    /// </summary>
    public interface IAopInterceptor
    {
        /// <summary>
        /// 执行前操作，同步方法调用
        /// </summary>
        /// <param name="context"></param>
        /// <returns></returns>
        AopContext Before(AopContext context);
        /// <summary>
        /// 执行前操作，异步方法调用
        /// </summary>
        /// <param name="context"></param>
        /// <returns></returns>
        ValueTask<AopContext> BeforeAsync(AopContext context);
        /// <summary>
        /// 执行后操作，同步方法调用
        /// </summary>
        /// <param name="context"></param>
        /// <returns></returns>
        AopContext After(AopContext context);
        /// <summary>
        /// 执行后操作，异步方法调用
        /// </summary>
        /// <param name="context"></param>
        /// <returns></returns>
        ValueTask<AopContext> AfterAsync(AopContext context);
        /// <summary>
        /// 执行方法，同步方法调用
        /// </summary>
        /// <param name="context"></param>
        /// <returns></returns>
        AopContext Next(AopContext context);
        /// <summary>
        /// 执行方法，异步方法调用
        /// </summary>
        /// <param name="context"></param>
        /// <returns></returns>
        ValueTask<AopContext> NextAsync(AopContext context);
    }

可以不要 IAopInterceptor 这个接口，这里加了只是为了约束。

    public class AopInterceptor : Attribute, IAopInterceptor
    {
        /// <summary>
        /// 是否执行 Before
        /// </summary>
        public bool HasBefore { get; set; }
        /// <summary>
        /// 是否执行 After
        /// </summary>
        public bool HasAfter { get; set; }
        /// <summary>
        /// 是否执行 Aop 的 Next
        /// </summary>
        public bool HasAopNext { get; set; }
        /// <summary>
        /// 是否执行实际的方法
        /// </summary>
        public bool HasActualNext { get; set; }

        /// <summary>
        /// 默认执行所以方法
        /// </summary>
        public AopInterceptor()
        {
            HasBefore = true;
            HasAopNext = true;
            HasActualNext = true;
            HasAfter = true;
        }

        public virtual AopContext Before(AopContext context) => context;

        public virtual async ValueTask<AopContext> BeforeAsync(AopContext context)
        {
            await ValueTask.CompletedTask;
            return context;
        }

        public virtual AopContext After(AopContext context)
        {
            return context.Exception != null ? throw context.Exception : context;
        }

        public virtual async ValueTask<AopContext> AfterAsync(AopContext context)
        {
            if (context.Exception != null)
                throw context.Exception;

            await ValueTask.CompletedTask;
            return context;
        }

        public virtual AopContext Next(AopContext context)
        {
            try
            {
                context.Invoke();
            }
            catch (Exception e)
            {
                context.Exception = e;
            }
            return context;
        }

        public virtual async ValueTask<AopContext> NextAsync(AopContext context)
        {
            try
            {
                context = await context.InvokeAsync();
            }
            catch (Exception e)
            {
                context.Exception = e;
            }

            return context;
        }
    }