.NET?Core?使用委托實現(xiàn)動態(tài)流程組裝的思路詳解

更新時間：2022年01月11日 17:01:51 作者：極客Bob

模擬管道模型中間件(Middleware)部分，運用委托，進行動態(tài)流程組裝，本次代碼實現(xiàn)就直接我之前寫的動態(tài)代理實現(xiàn)AOP的基礎(chǔ)上改的，就不另起爐灶了，主要思路就是運用委托，具體實現(xiàn)過程跟隨小編一起看看吧

引言

在看.NET Core 源碼的管道模型中間件(Middleware)部分，覺得這個流程組裝，思路挺好的，于是就分享給大家。本次代碼實現(xiàn)就直接我之前寫的動態(tài)代理實現(xiàn)AOP的基礎(chǔ)上改的，就不另起爐灶了，主要思路就是運用委托。對委托不理解的可留言，我寫一篇委托的常規(guī)使用方式，以及底層原理（編譯器）的文章

沒看過上一章的，我這里大家給貼一下地址：.NET Core 實現(xiàn)動態(tài)代理做AOP(面向切面編程)

接下來進入正題

1.定義接口IInterceptor

定義好我們AOP需要實現(xiàn)的接口，不同職責(zé)可以定義不同接口，大家根據(jù)實際情況劃分

 internal interface IInterceptor
    {
    }
    internal interface IInterceptorAction : IInterceptor
    {
        /// <summary>
        /// 執(zhí)行之前
        /// </summary>
        /// <param name="args">參數(shù)</param>
        void AfterAction(object?[]? args);
        /// <summary>
        /// 執(zhí)行之后
        /// </summary>
        /// <param name="args">參數(shù)</param>
        /// <param name="result">結(jié)果</param>
        void BeforeAction(object?[]? args, object? result);
    }

2.定義特性

這里只定義一個基類特性類，繼承標記接口，用于設(shè)置共通配置，且利于后面反射查找

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

3.編寫生成代理類的邏輯

只需要繼承.NET CORE 原生DispatchProxy類，重寫相關(guān)業(yè)務(wù)代碼

3.1 編寫創(chuàng)建代理方法

編寫一個我們自己的Create方法()，這兩個參數(shù)為了后面調(diào)用目標類儲備的，方法實現(xiàn)就只需要調(diào)用DispatchProxy類的Create()

internal class DynamicProxy<T> : DispatchProxy
    {
        public T Decorated { get; set; }//目標類
        public IEnumerable<IInterceptorAction> Interceptors { get; set; }  // AOP動作
        /// <summary>
        /// 創(chuàng)建代理實例
        /// </summary>
        /// <param name="decorated">代理的接口類型</param>
        /// <param name="afterAction">方法執(zhí)行前執(zhí)行的事件</param>
        /// <param name="beforeAction">方法執(zhí)行后執(zhí)行的事件</param>
        /// <returns></returns>
        public T Create(T decorated, IEnumerable<IInterceptor> interceptors)
        {
            object proxy = Create<T, DynamicProxy<T>>(); // 調(diào)用DispatchProxy 的Create  創(chuàng)建一個代理實例
            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方法

這個就是需要實現(xiàn)我們自己的業(yè)務(wù)了，大家看注釋應(yīng)該就能看懂個大概了，目前這里只處理了IInterceptorAction接口邏輯，比如異常、異步等等，自己可按需實現(xiàn)。而流程組裝的精髓就三步

1.不直接去執(zhí)行targetMethod.Invoke()，而是把它放到委托里面。

2.定義AssembleAction()方法來組裝流程，方法里面也不執(zhí)行方法，也是返回一個執(zhí)行方法的委托。

3.循環(huán)事先在Create()方法存儲的特性實例，調(diào)用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繼續(xù)執(zhí)行
                {
                    exception = ex;
                }
                return null;
            };
            //進行倒序，使其按照由外置內(nèi)的流程執(zhí)行
            foreach (var c in Interceptors.Reverse())
            {
                action = AssembleAction(action, c);
            }
            //執(zhí)行組裝好的流程
            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) =>
            {
                //執(zhí)行之前的動作
                AfterAction(c.AfterAction, args);
                var result = action?.Invoke(args);
                //執(zhí)行之后的動作
                BeforeAction(c.BeforeAction, args, result);
                return result;
            };
        }
        private void AfterAction(Action<object?[]?> action, object?[]? args)
        {
            try
            {
                action(args);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"執(zhí)行之前異常：{ex.Message}，{ex.StackTrace}");
            }
        }
        private void BeforeAction(Action<object?[]?, object?> action, object?[]? args, object? result)
        {
            try
            {
                action(args, result);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"執(zhí)行之后異常：{ex.Message}，{ex.StackTrace}");
            }
        }
    }

4.定義一個工廠

工廠用于專門來為我們創(chuàng)建代理類，邏輯很簡單，后續(xù)大家也可以按需編寫，目前邏輯就是利用反射獲取目標類的特性，把參數(shù)組裝起來。

internal class ProxyFactory
    {
        /// <summary>
        /// 創(chuàng)建代理實例
        /// </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>();
            //創(chuàng)建代理類
            var proxy = new DynamicProxy<T>().Create(decorated, interceptAttribut);
            return proxy;
        }
    }

5.定義ServiceHelp

這個是為了使得我們?nèi)种挥靡粋€作用域的IOC容器

public static class ServiceHelp
    {
        public static IServiceProvider? serviceProvider { get; set; }
        public static void BuildServiceProvider(IServiceCollection serviceCollection)
        {
            //構(gòu)建容器
            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 編程AOP實現(xiàn)

寫兩個特性實現(xiàn)，繼承基類特性，實現(xiàn)Action接口邏輯，測試兩個特性隨意調(diào)換位置進行組裝流程

internal class AOPTest1Attribut : BaseInterceptAttribute, IInterceptorAction
    {
        public void AfterAction(object?[]? args)
        {
            Console.WriteLine($"AOP1方法執(zhí)行之前，args：{args[0] + "," + args[1]}");
            // throw new Exception("異常測試（異常，但依然不能影響程序執(zhí)行）");
        }
        public void BeforeAction(object?[]? args, object? result)
        {
            Console.WriteLine($"AOP1方法執(zhí)行之后，result：{result}");
        }
    }
    internal class AOPTest2Attribut : BaseInterceptAttribute, IInterceptorAction
    {
        public void AfterAction(object?[]? args)
        {
            Console.WriteLine($"AOP2方法執(zhí)行之前，args：{args[0] + "," + args[1]}");
        }
        public void BeforeAction(object?[]? args, object? result)
        {
            Console.WriteLine($"AOP2方法執(zhí)行之后，result：{result}");
        }
    }

6.2 編寫測試服務(wù)

寫一個簡單的測試服務(wù)，就比如兩個整數(shù)相加，然后標記上我們寫的AOP特性

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($"正在執(zhí)行--》Add({a},)");
            //throw new Exception("方法執(zhí)行--》測試異常");
            return a + b;
        }
    }

6.3 調(diào)用

1.把服務(wù)注冊到IOC

2.調(diào)用創(chuàng)建代理類的工廠

3.調(diào)用測試服務(wù)函數(shù)：.Add(1, 2)

IServiceCollection serviceCollection = new ServiceCollection();
serviceCollection.AddTransient<ITestService, TestService>();
ServiceHelp.BuildServiceProvider(serviceCollection);
//用工廠獲取代理實例
var s = ProxyFactory.Create<ITestService>();
var sum = s.Add(1, 2);