本文有配套視頻：

https://www.bilibili.com/video/av58096866/?p=6

?前言

上回《【 .NET Core3.0 】框架之九 || 依賴注入IoC學(xué)習(xí) + AOP界面編程初探》咱們說到了依賴注入Autofac的使用，不知道大家對IoC的使用是怎樣的感覺，我個人表示還是比較可行的，至少不用自己再關(guān)心一個個復(fù)雜的實例化服務(wù)對象了，直接通過接口就滿足需求，當(dāng)然還有其他的一些功能，我還沒有說到，拋磚引玉嘛，大家如果有好的想法，歡迎留言，也可以來群里，大家一起學(xué)習(xí)討論。昨天在文末咱們說到了AOP面向切面編程的定義和思想，我個人簡單使用了下，感覺主要的思路還是通過攔截器來操作，就像是一個中間件一樣，今天呢，我給大家說兩個小栗子，當(dāng)然，你也可以合并成一個，也可以自定義擴(kuò)展，因為我們是真?zhèn)€系列是基于Autofac框架，所以今天主要說的是基于Autofac的Castle動態(tài)代理的方法，靜態(tài)注入的方式以后有時間可以再補(bǔ)充。

　　時間真快，轉(zhuǎn)眼已經(jīng)十天過去了，感謝大家的鼓勵，批評指正，希望我的文章，對您有一點點兒的幫助，哪怕是有學(xué)習(xí)新知識的動力也行，至少至少，可以為以后跳槽增加新的談資 [哭笑]，這些天我們從面向?qū)ο驩OP的開發(fā)，后又轉(zhuǎn)向了面向接口開發(fā)，到分層解耦，現(xiàn)在到了面向切面編程AOP，往下走將會是，分布式，微服務(wù)等等，技術(shù)真是永無止境啊！好啦，馬上開始動筆。

? 一、什么是 AOP 切面編程思想

什么是AOP？引用百度百科：AOP為Aspect Oriented Programming的縮寫，意為：面向切面編程，通過預(yù)編譯方式和運行期動態(tài)代理實現(xiàn)程序功能的統(tǒng)一維護(hù)的一種技術(shù)。實現(xiàn)AOP主要由兩種方式，

一種是編譯時靜態(tài)織入，優(yōu)點是效率高，缺點是缺乏靈活性，.net下postsharp為代表者(好像是付費了。。)。

另一種方式是動態(tài)代理，優(yōu)點是靈活性強(qiáng)，但是會影響部分效率，動態(tài)為目標(biāo)類型創(chuàng)建代理，通過代理調(diào)用實現(xiàn)攔截。

AOP能做什么，常見的用例是事務(wù)處理、日志記錄等等。

常見的AOP都是配合在Ioc的基礎(chǔ)上進(jìn)行操作，上邊咱們講了Autofac這個簡單強(qiáng)大的Ioc框架，下面就講講Autofac怎么實現(xiàn)AOP。Autofac的AOP是通過Castle(也是一個容器)項目的核心部分實現(xiàn)的，名為Autofac.Extras.DynamicProxy,顧名思義，其實現(xiàn)方式為動態(tài)代理。當(dāng)然AOP并不一定要和依賴注入在一起使用，自身也可以單獨使用。

是不是很拗口，沒關(guān)系，網(wǎng)上有一個博友的圖片，大概講了AOP切面編程：

?

說的很通俗易懂的話就是，我們在 service 方法的前邊和后邊，各自動態(tài)增加了一個方法，這樣就包裹了每一個服務(wù)方法，從而實現(xiàn)業(yè)務(wù)邏輯的解耦。

AOP，我們并不陌生。可能大家感覺這個切面編程思想之前沒有用到過，很新鮮的一個東西，其實不是的，之前我們開發(fā)的時候也一直在使用這種思想，那就是過濾器，我們可以想想，我們之前在開發(fā) MVC 的時候，是不是經(jīng)常要對action進(jìn)行控制過濾，最常見的就是全局異常處理過濾器，只要有錯誤，就跳出去，記錄日志，然后去一個自定義的異常頁面，這個其實就是一個 AOP 的思想，但是這里請注意，這個思想是廣義的 AOP 編程思想，今天要說的，是真正意義上的切面編程思想，是基于動態(tài)代理的基于服務(wù)層的編程思想，也是在以后的開發(fā)中使用很多的一種編程思想。

?二、AOP 之實現(xiàn)日志記錄

首先想一想，如果有這么一個需求，要記錄整個項目的接口和調(diào)用情況，當(dāng)然如果只是控制器的話，還是挺簡單的，直接用一個過濾器或者一個中間件，還記得咱們開發(fā)Swagger攔截權(quán)限驗證的中間件么，那個就很方便的把用戶調(diào)用接口的名稱記錄下來，當(dāng)然也可以寫成一個切面，但是如果想看下與Service或者Repository層的調(diào)用情況呢，好像目前咱們只能在Service層或者Repository層去寫日志記錄了，那樣的話，不僅工程大(當(dāng)然你可以用工廠模式)，而且耦合性瞬間就高了呀，想象一下，如果日志要去掉，關(guān)閉，修改，需要改多少地方！您說是不是，好不容易前邊的工作把層級的耦合性降低了。別慌，這個時候就用到了AOP和Autofac的Castle結(jié)合的完美解決方案了。

　　經(jīng)過這么多天的開發(fā)，幾乎每天都需要引入Nuget包哈，我個人表示也不想再添加了，現(xiàn)在都已經(jīng)挺大的了(47M當(dāng)然包括全部dll文件),今天不會啦！其實都是基于昨天的兩個Nuget包中已經(jīng)自動生成的Castle組件。請看以下步驟：

1、定義服務(wù)接口與實現(xiàn)類

在上一篇文章中，我們說到了使用

AdvertisementServices.cs 和 IAdvertisementServices.cs

這個服務(wù)，我們新建兩個層，分別包含這兩個 cs 文件：

然后我們模擬下數(shù)據(jù)，再新建一個 Model 層，添加 AdvertisementEntity 實體類

namespace Blog.Core.Model{ public class AdvertisementEntity { public int id { get; set; } public string name { get; set; } }}

然后在上邊的 service 方法中，返回一個List數(shù)據(jù)：

// 接口 public interface IAdvertisementServices { int Test(); ListTestAOP(); } // 實現(xiàn)類 public class AdvertisementServices : IAdvertisementServices { public int Test() { return 1; } public ListTestAOP() => new List() { new AdvertisementEntity() { id = 1, name = "laozhang" } }; }

2、在API層中添加對該接口引用

還是在默認(rèn)的控制器——weatherForecastController.cs 里，添加調(diào)用方法：

/// /// 測試AOP /// /// [HttpGet] public ListTestAdsFromAOP() { return _advertisementServices.TestAOP(); }

這里采用的是依賴注入的方法，把 _advertisementServices 注入到控制器的，如果還不會，請看我上一篇文章。

3、添加AOP攔截器

在api層新建文件夾AOP，添加攔截器BlogLogAOP，并設(shè)計其中用到的日志記錄Logger方法或者類

關(guān)鍵的一些知識點，注釋中已經(jīng)說明了，主要是有以下：

1、繼承接口IInterceptor2、實例化接口IINterceptor的唯一方法Intercept3、void Proceed();表示執(zhí)行當(dāng)前的方法4、執(zhí)行后，輸出到日志文件。

namespace blog.core.test3._0.AOP{ /// /// 攔截器BlogLogAOP 繼承IInterceptor接口 /// public class BlogLogAOP : IInterceptor { /// /// 實例化IInterceptor唯一方法 /// /// 包含被攔截方法的信息 public void Intercept(IInvocation invocation) { // 事前處理: 在服務(wù)方法執(zhí)行之前,做相應(yīng)的邏輯處理 var dataIntercept = "" + $"【當(dāng)前執(zhí)行方法】：{ invocation.Method.Name} \r\n" + $"【攜帶的參數(shù)有】： {string.Join(", ", invocation.Arguments.Select(a => (a ?? "").ToString()).ToArray())} \r\n"; // 執(zhí)行當(dāng)前訪問的服務(wù)方法,(注意:如果下邊還有其他的AOP攔截器的話,會跳轉(zhuǎn)到其他的AOP里) invocation.Proceed(); // 事后處理: 在service被執(zhí)行了以后,做相應(yīng)的處理,這里是輸出到日志文件 dataIntercept += ($"【執(zhí)行完成結(jié)果】：{invocation.ReturnValue}"); // 輸出到日志文件 Parallel.For(0, 1, e => { LogLock.OutSql2Log("AOPLog", new string[] { dataIntercept }); }); } }}

提示：這里展示了如何在項目中使用AOP實現(xiàn)對 service 層進(jìn)行日志記錄，如果你想實現(xiàn)異常信息記錄的話，很簡單，

注意，這個方法僅僅是針對同步的策略，如果你的service是異步的，這里獲取不到，正確的寫法，在文章底部的 GitHub 代碼里，因為和 AOP 思想沒有直接的關(guān)系，這里就不贅述。

4、將攔截器注入容器，代理服務(wù)

還記得昨天的Autofac容器 ConfigureContainer 么，我們繼續(xù)對它進(jìn)行處理：

1、先把攔截器注入容器；

2、然后對程序集的注入方法中匹配攔截器服務(wù)；

public void ConfigureContainer(ContainerBuilder builder) { var basePath = Microsoft.DotNet.PlatformAbstractions.ApplicationEnvironment.ApplicationBasePath; //直接注冊某一個類和接口 //左邊的是實現(xiàn)類，右邊的As是接口 builder.RegisterType().As(); builder.RegisterType();//可以直接替換其他攔截器！一定要把攔截器進(jìn)行注冊 //注冊要通過反射創(chuàng)建的組件 var servicesDllFile = Path.Combine(basePath, "Blog.Core.Services.dll"); var assemblysServices = Assembly.LoadFrom(servicesDllFile); builder.RegisterAssemblyTypes(assemblysServices) .AsImplementedInterfaces() .InstancePerLifetimeScope() .EnableInterfaceInterceptors() .InterceptedBy(typeof(BlogLogAOP));//可以放一個AOP攔截器集合 }

注意其中的兩個方法

.EnableInterfaceInterceptors()//對目標(biāo)類型啟用接口攔截。攔截器將被確定，通過在類或接口上截取屬性, 或添加 InterceptedBy ()

.InterceptedBy(typeof(BlogLogAOP));//允許將攔截器服務(wù)的列表分配給注冊。

說人話就是，將攔截器添加到要注入容器的接口或者類之上。

5、運行項目，查看效果

這個時候，我們運行項目，然后訪問api 的 TestAdsFromAOP() 接口，你就看到這根目錄下生成了一個Log文件夾，里邊有日志記錄，當(dāng)然記錄很簡陋，里邊是獲取到的實體類，大家可以自己根據(jù)需要擴(kuò)展。

這里，面向服務(wù)層的日志記錄就完成了，大家感覺是不是很平時的不一樣？我們幾乎什么都沒做，只是增加了一個AOP的攔截器，就可以控制 service 層的任意一個方法，這就是AOP思想的精髓——業(yè)務(wù)的解耦。

那AOP僅僅是做日志記錄么，還有沒有其他的用途，這里我隨便舉一個例子——緩存。

?三、AOP 實現(xiàn)數(shù)據(jù)緩存功能

想一想，如果我們要實現(xiàn)緩存功能，一般咱們都是將數(shù)據(jù)獲取到以后，定義緩存，然后在其他地方使用的時候，在根據(jù)key去獲取當(dāng)前數(shù)據(jù)，然后再操作等等，平時都是在API接口層獲取數(shù)據(jù)后進(jìn)行緩存，今天咱們可以試試，在接口之前就緩存下來 —— 基于service層的緩存策略。

1、定義 Memory 緩存類和接口

這里既然要用到緩存，那我們就定義一個緩存類和接口，在 Helper 文件夾下，新建兩個類文件，ICaching.cs 和 MemoryCaching.cs

你會問了，為什么上邊的日志沒有定義，因為我會在之后講Redis的時候用到這個緩存接口。

/// /// 簡單的緩存接口，只有查詢和添加，以后會進(jìn)行擴(kuò)展 /// public interface ICaching {????????object?Get(string?cacheKey); void Set(string cacheKey, object cacheValue); }　　 /// /// 實例化緩存接口ICaching /// public class MemoryCaching : ICaching { //引用Microsoft.Extensions.Caching.Memory;這個和.net 還是不一樣，沒有了Httpruntime了 private IMemoryCache _cache; //還是通過構(gòu)造函數(shù)的方法，獲取 public MemoryCaching(IMemoryCache cache) { _cache = cache; } public object Get(string cacheKey) { return _cache.Get(cacheKey); } public void Set(string cacheKey, object cacheValue) { _cache.Set(cacheKey, cacheValue, TimeSpan.FromSeconds(7200)); } }

2、定義一個緩存攔截器

還是繼承IInterceptor，并實現(xiàn)Intercept，這個過程和上邊 日志AOP 是一樣，不多說，大家也正好可以自己動手練習(xí)一下。

新建緩存AOP：BlogCacheAOP.cs

/// /// 面向切面的緩存使用 /// ?public?class?BlogCacheAOP?:?AOPbase { //通過注入的方式，把緩存操作接口通過構(gòu)造函數(shù)注入 private readonly ICaching _cache; public BlogCacheAOP(ICaching cache) { _cache = cache; } //Intercept方法是攔截的關(guān)鍵所在，也是IInterceptor接口中的唯一定義 public override void Intercept(IInvocation invocation)?????{ //獲取自定義緩存鍵 var cacheKey = CustomCacheKey(invocation); //根據(jù)key獲取相應(yīng)的緩存值 var cacheValue = _cache.Get(cacheKey); if (cacheValue != null) { //將當(dāng)前獲取到的緩存值，賦值給當(dāng)前執(zhí)行方法 invocation.ReturnValue = cacheValue; return; } //去執(zhí)行當(dāng)前的方法 invocation.Proceed(); //存入緩存 if (!string.IsNullOrWhiteSpace(cacheKey)) { _cache.Set(cacheKey, invocation.ReturnValue); } } }

代碼中注釋的很清楚，需要注意是兩點：

1、采用依賴注入，把緩存注入到當(dāng)前攔截器里；

2、繼承了一個 AOPBase 抽象類，里邊有如何定義緩存 key 等內(nèi)容；

namespace blog.core.test3._0.AOP{ public abstract class AOPbase : IInterceptor { /// /// AOP的攔截方法 /// /// public abstract void Intercept(IInvocation invocation); /// /// 自定義緩存的key /// /// /// protected string CustomCacheKey(IInvocation invocation) { var typeName = invocation.TargetType.Name; var methodName = invocation.Method.Name; var methodArguments = invocation.Arguments.Select(GetArgumentValue).Take(3).ToList();//獲取參數(shù)列表，最多三個 string key = $"{typeName}:{methodName}:"; foreach (var param in methodArguments) { key = $"{key}{param}:"; } return key.TrimEnd(':'); } /// /// object 轉(zhuǎn) string /// /// /// protected static string GetArgumentValue(object arg) { if (arg is DateTime || arg is DateTime?) return ((DateTime)arg).ToString("yyyyMMddHHmmss"); if (arg is string || arg is ValueType || arg is Nullable) return arg.ToString(); if (arg != null) { if (arg.GetType().IsClass) { return MD5Encrypt16(Newtonsoft.Json.JsonConvert.SerializeObject(arg)); } } return string.Empty; } /// /// 16位MD5加密 /// /// /// public static string MD5Encrypt16(string password) { var md5 = new MD5CryptoServiceProvider(); string t2 = BitConverter.ToString(md5.ComputeHash(Encoding.Default.GetBytes(password)), 4, 8); t2 = t2.Replace("-", string.Empty); return t2; } }}

3、注入攔截器到服務(wù)

具體的操作方法，上邊我們都已經(jīng)說到了，大家依然可以自己練習(xí)一下，這里直接把最終的代碼展示一下：

注意：

//將 TService 中指定的類型的范圍服務(wù)添加到實現(xiàn)?services.AddScoped();//記得把緩存注入！！！

4、運行，查看效果

你會發(fā)現(xiàn)，首次緩存是空的，然后將serv中取出來的數(shù)據(jù)存入緩存，第二次使用就是有值了，其他所有的地方使用，都不用再寫了，而且也是面向整個程序集合的

5、多個AOP執(zhí)行順序問題?

在我最新的 Github 項目中，我定義了四個 AOP ：除了上邊兩個 LogAOP和 CacheAOP 以外，還有一個 RedisCacheAOP 和 事務(wù)BlogTranAOP，并且通過開關(guān)的形式在項目中配置是否啟用：

那具體的執(zhí)行順序是什么呢，這里說下，就是從上至下的順序，或者可以理解成挖金礦的形式，執(zhí)行完上層的，然后緊接著來下一個AOP，最后想要回家，就再一個一個跳出去，在往上層走的時候，礦肯定就執(zhí)行完了，就不用再操作了，直接出去，就像 break 一樣。

6、無接口如何實現(xiàn)AOP

上邊我們討論了很多，但是都是接口框架的，

比如：Service.dll 和與之對應(yīng)的 IService.dll，Repository.dll和與之對應(yīng)的 IRepository.dll，我們可以直接在對應(yīng)的層注入的時候，匹配上 AOP 信息，但是如果我們沒有使用接口怎么辦？

這里大家可以安裝下邊的實驗下:

Autofac它只對接口方法 或者 虛virtual方法或者重寫方法override才能起攔截作用。??

如果沒有接口

案例是這樣的：

?如果我們的項目是這樣的，沒有接口，會怎么辦：

// 服務(wù)層類 public class StudentService { StudentRepository _studentRepository; public StudentService(StudentRepository studentRepository) { _studentRepository = studentRepository; } public string Hello() { return _studentRepository.Hello();????????} } // 倉儲層類 public class StudentRepository { public StudentRepository()????????{????????} public string Hello() { return "hello world!!!"; } } // controller 接口調(diào)用 StudentService _studentService; public ValuesController(StudentService studentService) { _studentService = studentService;????}

如果是沒有接口的單獨實體類

public class Love{ // 一定要是虛方法 public virtual string SayLoveU() { return "I ? U";????}}//---------------------------//只能注入該類中的虛方法builder.RegisterAssemblyTypes(Assembly.GetAssembly(typeof(Love))) .EnableClassInterceptors() .InterceptedBy(typeof(BlogLogAOP));

到了這里，我們已經(jīng)明白了什么是AOP切面編程，也通過兩個業(yè)務(wù)邏輯學(xué)會了如何去使用AOP編程，那這里有一個小問題，如果我某些service類和方法并不想做相應(yīng)的AOP處理，該如何篩選呢？請繼續(xù)看。

?四、給緩存增加驗證篩選

1、自定義緩存特性

在解決方案中添加新項目Blog.Core.Common，然后在該Common類庫中添加 特性文件夾 和 特性實體類，以后特性就在這里

　　/// /// 這個Attribute就是使用時候的驗證，把它添加到要緩存數(shù)據(jù)的方法中，即可完成緩存的操作。注意是對Method驗證有效 /// [AttributeUsage(AttributeTargets.Method, Inherited = true)] public class CachingAttribute : Attribute { //緩存絕對過期時間 public int AbsoluteExpiration { get; set; } = 30; }

2、在AOP攔截器中進(jìn)行過濾

添加Common程序集引用，然后修改緩存AOP類方法 BlogCacheAOP=》Intercept，簡單對方法的方法進(jìn)行判斷

/// /// 面向切面的緩存使用/// public class BlogCacheAOP : AOPbase{ //通過注入的方式，把緩存操作接口通過構(gòu)造函數(shù)注入 private readonly ICaching _cache; public BlogCacheAOP(ICaching cache) { _cache = cache; } //Intercept方法是攔截的關(guān)鍵所在，也是IInterceptor接口中的唯一定義 public override void Intercept(IInvocation invocation) { var method = invocation.MethodInvocationTarget ?? invocation.Method; //對當(dāng)前方法的特性驗證 var qCachingAttribute = method.GetCustomAttributes(true).FirstOrDefault(x => x.GetType() == typeof(CachingAttribute)) as CachingAttribute; //只有那些指定的才可以被緩存，需要驗證 if (qCachingAttribute != null)????????{ //獲取自定義緩存鍵 var cacheKey = CustomCacheKey(invocation); //根據(jù)key獲取相應(yīng)的緩存值 var cacheValue = _cache.Get(cacheKey); if (cacheValue != null) { //將當(dāng)前獲取到的緩存值，賦值給當(dāng)前執(zhí)行方法 invocation.ReturnValue = cacheValue; return; } //去執(zhí)行當(dāng)前的方法 invocation.Proceed(); //存入緩存 if (!string.IsNullOrWhiteSpace(cacheKey)) { _cache.Set(cacheKey, invocation.ReturnValue); } } }}

我們增加了一個 if 判斷，只有那些帶有緩存特性的類和方法才會被執(zhí)行這個 AOP 攔截。

3、在service層中增加緩存特性

在指定的Service層中的某些類的某些方法上增加特性(一定是方法，不懂的可以看定義特性的時候AttributeTargets.Method)

4、特定緩存效果展示

運行項目，打斷點，就可以看到，普通的Query或者CURD等都不繼續(xù)緩存了，只有咱們特定的 getBlogs()方法，帶有緩存特性的才可以

當(dāng)然，這里還有一個小問題，就是所有的方法還是走的切面，只是增加了過濾驗證，大家也可以直接把那些需要的注入，不需要的干脆不注入Autofac容器，我之所以需要都經(jīng)過的目的，就是想把它和日志結(jié)合，用來記錄Service層的每一個請求，包括CURD的調(diào)用情況。

五、基于AOP的Redis緩存

1、核心：Redis緩存切面攔截器

?在上篇文章中，我們已經(jīng)定義過了一個攔截器，只不過是基于內(nèi)存Memory緩存的，并不適應(yīng)于Redis，上邊咱們也說到了Redis必須要存入指定的值，比如字符串，而不能將異步對象 Task 保存到硬盤上，所以我們就修改下攔截器方法，一個專門應(yīng)用于 Redis 的切面攔截器：

/// /// 面向切面的緩存使用 /// public class BlogRedisCacheAOP : CacheAOPbase { //通過注入的方式，把緩存操作接口通過構(gòu)造函數(shù)注入 private readonly IRedisCacheManager _cache; public BlogRedisCacheAOP(IRedisCacheManager cache) { _cache = cache; } //Intercept方法是攔截的關(guān)鍵所在，也是IInterceptor接口中的唯一定義 public override void Intercept(IInvocation invocation) { var method = invocation.MethodInvocationTarget ?? invocation.Method; //對當(dāng)前方法的特性驗證 var qCachingAttribute = method.GetCustomAttributes(true).FirstOrDefault(x => x.GetType() == typeof(CachingAttribute)) as CachingAttribute; if (qCachingAttribute != null) { //獲取自定義緩存鍵 var cacheKey = CustomCacheKey(invocation); //注意是 string 類型，方法GetValue var cacheValue = _cache.GetValue(cacheKey); if (cacheValue != null) { //將當(dāng)前獲取到的緩存值，賦值給當(dāng)前執(zhí)行方法 var type = invocation.Method.ReturnType; var resultTypes = type.GenericTypeArguments; if (type.FullName == "System.Void") { return; } object response; if (typeof(Task).IsAssignableFrom(type)) { //返回Task if (resultTypes.Any()) { var resultType = resultTypes.FirstOrDefault(); // 核心1，直接獲取 dynamic 類型????????????????????????????dynamic?temp?=?Newtonsoft.Json.JsonConvert.DeserializeObject(cacheValue,?resultType);??????????????????????????????????????????????????????response?=?Task.FromResult(temp); } else { //Task 無返回方法 指定時間內(nèi)不允許重新運行 response = Task.Yield(); } } else { // 核心2，要進(jìn)行 ChangeType response = Convert.ChangeType(_cache.Get<object>(cacheKey), type); } invocation.ReturnValue = response; return; } //去執(zhí)行當(dāng)前的方法 invocation.Proceed(); //存入緩存 if (!string.IsNullOrWhiteSpace(cacheKey)) { object response; //Type type = invocation.ReturnValue?.GetType(); var type = invocation.Method.ReturnType; if (typeof(Task).IsAssignableFrom(type)) { var resultProperty = type.GetProperty("Result"); response = resultProperty.GetValue(invocation.ReturnValue); } else { response = invocation.ReturnValue; } if (response == null) response = string.Empty; _cache.Set(cacheKey, response, TimeSpan.FromMinutes(qCachingAttribute.AbsoluteExpiration)); } } else { invocation.Proceed();//直接執(zhí)行被攔截方法 } } }

上邊的代碼和memory緩存的整體結(jié)構(gòu)差不多的，相信都能看的懂的，最后我們就可以很任性的在Autofac容器中，進(jìn)行任意緩存切換了，是不是很棒！

再次感覺小伙伴JoyLing，不知道他博客園地址。

?六、一些其他問題需要考慮

1、時間問題，阻塞，浪費資源問題等

?　定義切面有時候是方便，初次使用會很別扭，使用多了，可能會對性能有些許的影響，因為會大量動態(tài)生成代理類，性能損耗，是特別高的請求并發(fā)，比如萬級每秒，還是要深入的研究，不可隨意使用，但是基本平時開發(fā)的時候，還是可以使用的，畢竟性價比挺高的，我說的也是九牛一毛，大家繼續(xù)加油吧！

2、靜態(tài)注入

基于Net的IL語言層級進(jìn)行注入，性能損耗可以忽略不計，Net使用最多的Aop框架PostSharp(好像收費了；)采用的即是這種方式。

大家可以參考這個博文：https://www.cnblogs.com/mushroom/p/3932698.html

?七、CODE

https://github.com/anjoy8/Blog.Core

https://gitee.com/laozhangIsPhi/Blog.Core

總結(jié)

以上是生活随笔為你收集整理的切面是异步还是同步操作‘_【 .NET Core 3.0 】框架之十 || AOP 切面思想的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。