菜渣开源一个基于 EMIT 的 AOP 库(.NET Core)

目录

• 1,快速入门
  • 1.1 继承 ActionAttribute 特性
  • 1.2 标记代理类型
  • 2，如何创建代理类型
    • 2.1 通过API直接创建
• 2,创建代理类型
  • 通过API
  • 通过 Microsoft.Extensions.DependencyInjection
    • 通过 Autofac
• 3,深入使用
  • 代理类型
  • 方法、属性代理
  • 上下文
    • 拦截方法或属性的参数
  • 非侵入式代理

Nuget 库地址：https://www.nuget.org/packages/CZGL.AOP/

Github 库地址：https://github.com/whuanle/CZGL.AOP

CZGL.AOP 是 基于 EMIT 编写的 一个简单轻量的AOP框架，支持非侵入式代理，支持.NET Core/ASP.NET Core，以及支持多种依赖注入框架。

1,快速入门

CZGL.AOP 使用比较简单，你只需要使用 [Interceptor] 特性标记需要代理的类型，然后使用继承 ActionAttribute 的特性标记要被代理的方法或属性。

1.1 继承 ActionAttribute 特性

ActionAttribute 是用于代理方法或属性的特性标记，不能直接使用，需要继承后重写方法。

示例如下：

    public class LogAttribute : ActionAttribute
    {
        public override void Before(AspectContext context)
        {
            Console.WriteLine("执行前");
        }

        public override object After(AspectContext context)
        {
            Console.WriteLine("执行后");
            if (context.IsMethod)
                return context.MethodResult;
            else if (context.IsProperty)
                return context.PropertyValue;
            return null;
        }
    }

Before 会在被代理的方法执行前或被代理的属性调用时生效，你可以通过 AspectContext 上下文，获取、修改传递的参数。

After 在方法执行后或属性调用时生效，你可以通过上下文获取、修改返回值。

1.2 标记代理类型

在被代理的类型中，使用 [Interceptor] 特性来标记，在需要代理的方法中，使用 继承了 ActionAttribute 的特性来标记。

此方法是侵入式的，需要在编译前完成。

[Interceptor]
public class Test : ITest
{
    [Log] public virtual string A { get; set; }
    [Log]
    public virtual void MyMethod()
    {
        Console.WriteLine("运行中");
    }
}

注意的是，一个方法或属性只能设置一个拦截器。

2，如何创建代理类型

CZGL.AOP 有多种生成代理类型的方式，下面介绍简单的方式。

请预先创建如下代码：

    public class LogAttribute : ActionAttribute
    {
        public override void Before(AspectContext context)
        {
            Console.WriteLine("执行前");
        }

        public override object After(AspectContext context)
        {
            Console.WriteLine("执行后");
            if (context.IsMethod)
                return context.MethodResult;
            else if (context.IsProperty)
                return context.PropertyValue;
            return null;
        }
    }

    public interface ITest
    {
        void MyMethod();
    }

    [Interceptor]
    public class Test : ITest
    {
        [Log] public virtual string A { get; set; }
        public Test()
        {
            Console.WriteLine("构造函数没问题");
        }
        [Log]
        public virtual void MyMethod()
        {
            Console.WriteLine("运行中");
        }
    }

2.1 通过API直接创建

通过 CZGL.AOP 中的 AopInterceptor 类，你可以生成代理类型。

示例如下：

            ITest test1 = AopInterceptor.CreateProxyOfInterface<ITest, Test>();
            Test test2 = AopInterceptor.CreateProxyOfClass<Test>();
            test1.MyMethod();
            test2.MyMethod();

CreateProxyOfInterface 通过接口创建代理类型；CreateProxyOfClass 通过类创建代理类型；

默认调用的是无参构造函数。

2,创建代理类型

通过API

你可以参考源码解决方案

中的 ExampleConsole 项目。

如果要直接使用 AopInterceptor.CreateProxyOfInterface 和 AopInterceptor.CreateProxyOfClass 方法，通过接口或类来创建代理类型。

        ITest test1 = AopInterceptor.CreateProxyOfInterface<ITest, Test>();
        Test test2 = AopInterceptor.CreateProxyOfClass<Test>();

如果要指定实例化的构造函数，可以这样：

            // 指定构造函数
            test2 = AopInterceptor.CreateProxyOfClass<Test>("aaa", "bbb");
            test2.MyMethod();

通过 Microsoft.Extensions.DependencyInjection

Microsoft.Extensions.DependencyInjection 是 .NET Core/ASP.NET Core 默认的依赖注入容器。

如果需要支持 ASP.NET Core 中使用 AOP，你可以在 Nuget 包中安装 CZGL.AOP.MEDI。

如果你在控制台下使用 Microsoft.Extensions.DependencyInjection，你可以使用名为 BuildAopProxy 的 IServiceCollection 拓展方法来为容器中的类型，生成代理类型。

示例如下：

            IServiceCollection _services = new ServiceCollection();
            _services.AddTransient<ITest, Test>();
            var serviceProvider = _services.BuildAopProxy().BuildServiceProvider();
            serviceProvider.GetService<ITest>();
            return serviceProvider;

你可以参考源码解决方案中的 ExampleMEDI 项目。

如果你要在 ASP.NET Core 中使用，你可以在 Startup 中，ConfigureServices 方法的最后一行代码使用 services.BuildAopProxy(); 。

        public void ConfigureServices(IServiceCollection services)
        {
            services.AddControllers();
            services.BuildAopProxy();
        }

还可以在 Program 的 IHostBuilder 中使用 .UseServiceProviderFactory(new AOPServiceProxviderFactory()) 来配置使用 CZGL.AOP。

示例：

        public static IHostBuilder CreateHostBuilder(string[] args) =>
            Host.CreateDefaultBuilder(args)
            .UseServiceProviderFactory(new AOPServiceProxviderFactory())
                .ConfigureWebHostDefaults(webBuilder =>
                {
                    webBuilder.UseStartup<Startup>();
                });

可以参考解决方案中的 ExampleConsole 和 ExampleWebMEDI 两个项目。

你不必担心引入 CZGL.AOP 后，使用依赖注入会使程序变慢或者破坏容器中的原有属性。CZGL.AOP 只会在创建容器时处理需要被代理的类型，不会影响容器中的服务，也不会干扰到依赖注入的执行。

通过 Autofac

如果需要在 Autofac 中使用 AOP，则需要引用 CZGL.AOP.Autofac 包。

如果你在控制台程序中使用 Autofac，则可以在 Build() 后面使用 BuildAopProxy()。

            ContainerBuilder builder = new ContainerBuilder();
            builder.RegisterType<Test>().As<ITest>();
            var container = builder.Build().BuildAopProxy();

            using (ILifetimeScope scope = container.BeginLifetimeScope())
            {
                // 获取实例
                ITest myService = scope.Resolve<ITest>();
                myService.MyMethod();
            }

            Console.ReadKey();
        }

要注意的是，在已经完成的组件注册创建一个新的容器后，才能调用 BuildAopProxy() 方法，

这样针对一个新的容器你可以考虑是否需要对容器中的组件进行代理。

如果在 ASP.NET Core 中使用 Autofac，你需要在 Program 类的 IHostBuilder 中使用：

.UseServiceProviderFactory(new AutofacServiceProviderFactory())

如果需要代理已经注册的组件，则将其替换为：

 .UseServiceProviderFactory(new CZGL.AOP.Autofac.AOPServiceProxviderFactory())

请参考 源码解决方案中的 ExampleAutofac 和 ExampleWebAutofac 两个项目。

3,深入使用

代理类型

要被代理的类型，需要使用 [Interceptor]来标记，例如：

    [Interceptor]
    public class Test : ITest
    {
    }

支持泛型类型。

被代理的类型必须是可被继承的。

类型的构造函数没有限制，你可以随意编写。

在使用 API 创建代理类型并且实例化时，你可以指定使用哪个构造函数。

例如：

			string a="",b="",c="";
			ITest test1 = AopInterceptor.CreateProxyOfInterface<ITest, Test>(a,b,c);

API 会根据参数的多少以及参数的类型自动寻找合适的构造函数。

方法、属性代理

为了代理方法或属性，你需要继承 ActionAttribute 特性，然后为方法或属性标记此特性，并且将方法或属性设置为 virtual

一个类型中的不同方法，可以使用不同的拦截器。

        [Log1]
        public virtual void MyMethod1(){}

        [Log2]
        public virtual void MyMethod2(){}

对于属性，可以在属性上直接使用特性，或者只在 get 或 set 构造器使用。

        [Log] public virtual string A { get; set; }

        // 或
        public virtual string A { [Log] get; set; }

        // 或
        public virtual string A { get; [Log] set; }

如果在属性上使用特性，相当于 [Log] get; [Log] set;。

上下文

一个简单的方法或属性拦截标记是这样的：

    public class LogAttribute : ActionAttribute
    {
        public override void Before(AspectContext context)
        {
            Console.WriteLine("执行前");
        }

        public override object After(AspectContext context)
        {
            Console.WriteLine("执行后");
            if (context.IsMethod)
                return context.MethodResult;
            else if (context.IsProperty)
                return context.PropertyValue;
            return null;
        }
    }

AspectContext 的属性说明如下：

字段	说明
Type	当前被代理类型生成的代理类型
ConstructorParamters	类型被实例化时使用的构造函数的参数，如果构造函数没有参数，则 MethodValues.Length = 0，而不是 MethodValues 为 null。
IsProperty	当前拦截的是属性
PropertyInfo	当前被执行的属性的信息，可为 null。
PropertyValue	但调用的是属性时，返回 get 的结果或 set 的 value 值。
IsMethod	当前拦截的是方法
MethodInfo	当前方法的信息
MethodValues	方法被调用时传递的参数，如果此方法没有参数，则 MethodValues.Length = 0，而不是 MethodValues 为 null
MethodResult	方法执行返回的结果(如果有)

拦截方法或属性的参数

通过上下文，你可以修改方法或属性的参数以及拦截返回结果：

    public class LogAttribute : ActionAttribute
    {
        public override void Before(AspectContext context)
        {
            // 拦截并修改方法的参数
            for (int i = 0; i < context.MethodValues.Length; i++)
            {
                context.MethodValues[i] = (int)context.MethodValues[i] + 1;
            }
            Console.WriteLine("执行前");
        }

        public override object After(AspectContext context)
        {
            Console.WriteLine("执行后");

            // 拦截方法的执行结果
            context.MethodResult = (int)context.MethodResult + 664;

            if (context.IsMethod)
                return context.MethodResult;
            else if (context.IsProperty)
                return context.PropertyValue;
            return null;
        }
    }

    [Interceptor]
    public class Test
    {
        [Log]
        public virtual int Sum(int a, int b)
        {
            Console.WriteLine("运行中");
            return a + b;
        }
    }

            Test test = AopInterceptor.CreateProxyOfClass<Test>();

            Console.WriteLine(test.Sum(1, 1));

方法的参数支持 in、ref、out；支持泛型方法泛型属性。

非侵入式代理

此种方式不需要改动被代理的类型，你也可以代理程序集中的类型。

    public class LogAttribute : ActionAttribute
    {
        public override void Before(AspectContext context)
        {
            Console.WriteLine("执行前");
        }

        public override object After(AspectContext context)
        {
            Console.WriteLine("执行后");
            if (context.IsMethod)
                return context.MethodResult;
            else if (context.IsProperty)
                return context.PropertyValue;
            return null;
        }
    }

    public class TestNo
    {
        public virtual string A { get; set; }
        public virtual void MyMethod()
        {
            Console.WriteLine("运行中");
        }
    }

            TestNo test3 = AopInterceptor.CreateProxyOfType<TestNo>(new ProxyTypeBuilder()
                .AddProxyMethod(typeof(LogAttribute), typeof(TestNo).GetMethod(nameof(TestNo.MyMethod)))
                .AddProxyMethod(typeof(LogAttribute), typeof(TestNo).GetProperty(nameof(TestNo.A)).GetSetMethod()));

通过 ProxyTypeBuilder 来构建代理类型。

代理方法或属性都是使用 AddProxyMethod，第一个参数是要使用的拦截器，第二个参数是要拦截的方法。

如果要拦截属性，请分开设置属性的 get、set 构造。

如果多个方法或属性使用同一个拦截器，则可以这样：

            TestNo test3 = AopInterceptor.CreateProxyOfType<TestNo>(
                new ProxyTypeBuilder(new Type[] { typeof(LogAttribute) })
                .AddProxyMethod("LogAttribute", typeof(TestNo).GetMethod(nameof(TestNo.MyMethod)))
                .AddProxyMethod("LogAttribute", typeof(TestNo).GetProperty(nameof(TestNo.A)).GetSetMethod()));

            TestNo test3 = AopInterceptor.CreateProxyOfType<TestNo>(
                new ProxyTypeBuilder(new Type[] { typeof(LogAttribute) })
                .AddProxyMethod("LogAttribute", typeof(TestNo).GetMethod(nameof(TestNo.MyMethod)))
                .AddProxyMethod(typeof(LogAttribute2), typeof(TestNo).GetProperty(nameof(TestNo.A)).GetSetMethod()));

在构造函数中传递过去所需要的拦截器，然后在拦截时使用。