您的位置:首页 > 运维架构

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

whuanle 2020-06-18 21:40 10 查看 https://www.cnblogs.com/whuanl

目录

  • 2,创建代理类型
  • 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 M
    1044
    yMethod()
    {
    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
    包。

    如果你在 ad8 控制台程序中使用 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(){}

    对于属性,可以在属性上直 56c 接使用特性,或者只在 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 类型被实例化时使用的构造函数的参数,如果构造函数没 ad0 有参数,则 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
    17b8
    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()));

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

    标签: 
    相关文章推荐