欢迎光临
我的个人博客网站

.NET Core 利用委托进行动态流程组装


引言

在看.NET Core 源码的管道模型中间件(Middleware)部分,觉得这个流程组装,思路挺好的,于是就分享给大家。本次代码实现就直接我之前写的动态代理实现AOP的基础上直接改了,就不另起炉灶了,主要思路就是运用委托。对委托不理解的可留言,我写一篇委托的常规使用方式,以及底层原理(编译器)的文章

.NET Core 利用委托进行动态流程组装

没看过上一章的,我这里大家给贴一下地址:.NET Core 实现动态代理做AOP(面向切面编程) – 极客Bob – 博客园 (cnblogs.com)

 

接下来进入正题

1.定义接口IInterceptor

定义好我们AOP需要实现的接口,不同职责可以定义不同接口,大家根据实际情况划分

查看代码
    internal interface IInterceptor     {      }      internal interface IInterceptorAction : IInterceptor     {         /// <summary>         /// 执行之前         /// </summary>         /// <param name="args">参数</param>         void AfterAction(object?[]? args);           /// <summary>         /// 执行之后         /// </summary>         /// <param name="args">参数</param>         /// <param name="result">结果</param>         void BeforeAction(object?[]? args, object? result);     }

2.定义特性

这里只定义一个基类特性类,继承标记接口,用于设置共通配置,且利于后面反射查找

查看代码
    [AttributeUsage(AttributeTargets.Class)]     internal class BaseInterceptAttribute : Attribute, IInterceptor     {      }

3.编写生成代理类的逻辑

只需要继承.NET CORE 原生DispatchProxy类,重写相关业务代码

3.1 编写创建代理方法

编写一个我们自己的Create方法(),这两个参数为了后面调用目标类储备的,方法实现就只需要调用DispatchProxy类的Create()

查看代码
internal class DynamicProxy<T> : DispatchProxy     {         public T Decorated { get; set; }//目标类         public IEnumerable<IInterceptorAction> Interceptors { get; set; }  // AOP动作          /// <summary>         /// 创建代理实例         /// </summary>         /// <param name="decorated">代理的接口类型</param>         /// <param name="afterAction">方法执行前执行的事件</param>         /// <param name="beforeAction">方法执行后执行的事件</param>         /// <returns></returns>         public T Create(T decorated, IEnumerable<IInterceptor> interceptors)         {             object proxy = Create<T, DynamicProxy<T>>(); // 调用DispatchProxy 的Create  创建一个代理实例             DynamicProxy<T> proxyDecorator = (DynamicProxy<T>)proxy;             proxyDecorator.Decorated = decorated;             proxyDecorator.Interceptors = interceptors.Where(c=>c.GetType().GetInterface(typeof(IInterceptorAction).Name) == typeof(IInterceptorAction)).Select(c=>c as IInterceptorAction);             return (T)proxy;         }
3.2 重写Invoke方法

这个就是需要实现我们自己的业务了,大家看注释应该就能看懂个大概了,目前这里只处理了IInterceptorAction接口逻辑,比如异常、异步等等,自己可按需实现。而流程组装的精髓就三步

1.不直接去执行targetMethod.Invoke(),而是把它放到委托里面。

2.定义AssembleAction()方法来组装流程,方法里面也不执行方法,也是返回一个执行方法委托

3.循环事先在Create()方法存储的特性实例,调用AssembleAction()方法组装流程,这样就达到俄罗斯套娃那种效果了。

查看代码
 protected override object? Invoke(MethodInfo? targetMethod, object?[]? args)         {             Exception exception = null;//由委托捕获变量,用来存储异常             Func<object?[]?, object?> action = (args) =>             {                 try                 {                     return targetMethod?.Invoke(Decorated, args);                 }                 catch (Exception ex)//捕获异常,不影响AOP继续执行                 {                     exception = ex;                 }                 return null;             };             //进行倒序,使其按照由外置内的流程执行             foreach (var c in Interceptors.Reverse())             {                 action = AssembleAction(action, c);             }             //执行组装好的流程             var result = action?.Invoke(args);             //如果方法有异常抛出异常             if (exception != null)             {                 throw exception;             }             return result;         }          private Func<object?[]?, object?>? AssembleAction(Func<object?[]?, object?>? action, IInterceptorAction c)         {             return (args) =>             {                 //执行之前的动作                 AfterAction(c.AfterAction, args);                 var result = action?.Invoke(args);                 //执行之后的动作                 BeforeAction(c.BeforeAction, args, result);                 return result;             };         }           private void AfterAction(Action<object?[]?> action, object?[]? args)         {             try             {                 action(args);             }             catch (Exception ex)             {                 Console.WriteLine($"执行之前异常:{ex.Message},{ex.StackTrace}");             }         }          private void BeforeAction(Action<object?[]?, object?> action, object?[]? args, object? result)         {             try             {                 action(args, result);             }             catch (Exception ex)             {                 Console.WriteLine($"执行之后异常:{ex.Message},{ex.StackTrace}");             }         }       }

4.定义一个工厂

工厂用于专门来为我们创建代理类,逻辑很简单,后续大家也可以按需编写,目前逻辑就是利用反射获取目标类的特性,把参数组装起来。

查看代码
internal class ProxyFactory     {          /// <summary>         /// 创建代理实例         /// </summary>         /// <param name="decorated">代理的接口类型</param>         /// <returns></returns>         public static T Create<T>()         {             var decorated = ServiceHelp.GetService<T>();             var type = decorated.GetType();             var interceptAttribut = type.GetCustomAttributes<BaseInterceptAttribute>();             //创建代理类             var proxy = new DynamicProxy<T>().Create(decorated, interceptAttribut);             return proxy;         }      }

5.定义ServiceHelp

这个是为了使得我们全局只用一个作用域的IOC容器

查看代码
public static class ServiceHelp     {          public static IServiceProvider? serviceProvider { get; set; }          public static void BuildServiceProvider(IServiceCollection serviceCollection)         {             //构建容器             serviceProvider = serviceCollection.BuildServiceProvider();         }          public static T GetService<T>(Type serviceType)         {             return (T)serviceProvider.GetService(serviceType);         }          public static T GetService<T>()         {             return serviceProvider.GetService<T>();         }     }

6.测试

6.1 编写测试服务

写一个简单的测试服务,就比如两个整数相加

查看代码
internal interface ITestService     {         public int Add(int a, int b);     }      [AOPTest2Attribut]     [AOPTest1Attribut]     internal class TestService : ITestService     {         public int Add(int a, int b)         {             Console.WriteLine($"正在执行--》Add({a},{b})");             //throw new Exception("方法执行--》测试异常");             return a + b;         }     }

6.2编程AOP实现

写两个特性实现,继承基类特性,实现Action接口逻辑,测试两个特性随意调换位置进行组装流程

查看代码
internal class AOPTest1Attribut : BaseInterceptAttribute, IInterceptorAction     {         public void AfterAction(object?[]? args)         {             Console.WriteLine($"AOP1方法执行之前,args:{args[0] + "," + args[1]}");             // throw new Exception("异常测试(异常,但依然不能影响程序执行)");         }          public void BeforeAction(object?[]? args, object? result)         {             Console.WriteLine($"AOP1方法执行之后,result:{result}");         }     }      internal class AOPTest2Attribut : BaseInterceptAttribute, IInterceptorAction     {         public void AfterAction(object?[]? args)         {             Console.WriteLine($"AOP2方法执行之前,args:{args[0] + "," + args[1]}");         }          public void BeforeAction(object?[]? args, object? result)         {             Console.WriteLine($"AOP2方法执行之后,result:{result}");         }     }

6.3 调用

1.把服务注册到IOC

2.调用创建代理类的工厂

查看代码
IServiceCollection serviceCollection = new ServiceCollection(); serviceCollection.AddTransient<ITestService, TestService>(); ServiceHelp.BuildServiceProvider(serviceCollection); //用工厂获取代理实例 var s = ProxyFactory.Create<ITestService>(); var sum = s.Add(1, 2);

6.4 效果图

AOP1->AOP2->Add(a,b)

.NET Core 利用委托进行动态流程组装

AOP2->AOP1->Add(a,b)

.NET Core 利用委托进行动态流程组装

代码上传至gitee,AOP流程组装分支:https://gitee.com/luoxiangbao/dynamic-proxy.git

 

赞(0) 打赏
未经允许不得转载:张拓的天空 » .NET Core 利用委托进行动态流程组装
分享到: 更多 (0)

评论 抢沙发

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址

专业的IT技术经验分享 更专业 更方便

联系我们本站主机

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

微信扫一扫打赏