依賴倒置原則 A.高層次的模塊不應該依賴于低層次的模塊，他們都應該依賴于抽象。 B.抽象不應該依賴于具體，具體應該依賴于抽象。 依賴倒置原則 A.高層次的模塊不應該依賴于低層次的模塊，他們都應該依賴于抽象。 B.抽象不應該依賴于具體，具體應該依賴于抽象。

目錄

1概述

2意圖

3代碼實現

4結構圖

1概述編輯

所謂依賴倒置原則（Dependence Inversion Principle）就是要依賴于抽象，不要依賴于具體。簡單的說就是要求對抽象進行編程，不要對實現進行編程，這樣就降低了客戶與實現模塊間的耦合。

2意圖編輯

面向過程的開發，上層調用下層，上層依賴于下層，當下層劇烈變動時上層也要跟著變動，這就會導致模塊的復用性降低而且大大提高了開發的成本。 面向對象的開發很好的解決了這個問題，一般情況下抽象的變化概率很小，讓用戶程序依賴于抽象，實現的細節也依賴于抽象。即使實現細節不斷變動，只要抽象不變，客戶程序就不需要變化。這大大降低了客戶程序與實現細節的耦合度。 面向過程思想的結構圖： 圖一 背景1：公司是福特和本田公司的金牌合作伙伴，現要求開發一套自動駕駛系統，只要汽車上安裝該系統就可以實現無人駕駛，該系統可以在福特和本田車上使用，只要這兩個品牌的汽車使用該系統就能實現自動駕駛。于是有人做出了分析如圖一。 對于圖一分析：我們定義了一個AutoSystem類，一個FordCar類，一個HondaCar類。FordCar類和HondaCar類中各有三個方法:Run(啟動Car)、Turn(轉彎Car)、Stop(停止Car)，當然了一個汽車肯定不止這些功能，這里只要能說明問題即可。AutoSystem類是一個自動駕駛系統，自動操縱這兩輛車。

3代碼實現編輯

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73

publicclassHondaCar{ publicvoidRun() { Console.WriteLine("本田開始啟動了"); } publicvoidTurn() { Console.WriteLine("本田開始轉彎了"); } publicvoidStop() { Console.WriteLine("本田開始停車了"); } } publicclassFordCar { publicvoidRun() { Console.WriteLine("福特開始啟動了"); } publicvoidTurn() { Console.WriteLine("福特開始轉彎了"); } publicvoidStop() { Console.WriteLine("福特開始停車了"); } } publicclassAutoSystem { publicenumCarType{Ford,Honda}; privateHondaCarhcar=newHondaCar(); privateFordCarfcar=newFordCar(); privateCarTypetype; publicAutoSystem(CarTypetype) { this.type=type; } privatevoidRunCar() { if(type==CarType.Ford) { fcar.Run(); } else { hcar.Run(); } } privatevoidTurnCar() { if(type==CarType.Ford) { fcar.Turn(); } else { hcar.Turn(); } } privatevoidStopCar() { if(type==CarType.Ford) { fcar.Stop(); } else { hcar.Stop(); } } }

代碼分析：上面的程序確實能夠實現針對Ford和Honda車的無人駕駛，但是軟件是在不斷變化的，軟件的需求也在不斷的變化。 背景2：公司的業務做大了，同時成為了通用、三菱、大眾的金牌合作伙伴，于是公司要求該自動駕駛系統也能夠安裝在這3種公司生產的汽車上。于是我們不得不變動AutoSystem：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57

publicclassAutoSystem { publicenumCarType{Ford,Honda,Bmw}; HondaCarhcar=newHondaCar(); FordCarfcar=newFordCar(); BmwCarbcar=newBmwCar(); privateCarTypetype; publicAutoSystem(CarTypetype) { this.type=type; } privatevoidRunCar() { if(type==CarType.Ford) { fcar.Run(); } elseif(type==CarType.Honda) { hcar.Run(); } elseif(type==CarType.Bmw) { bcar.Run(); } } privatevoidTurnCar() { if(type==CarType.Ford) { fcar.Turn(); } elseif(type==CarType.Honda) { hcar.Turn(); } elseif(type==CarType.Bmw) { bcar.Turn(); } } privatevoidStopCar() { if(type==CarType.Ford) { fcar.Stop(); } elseif(type==CarType.Honda) { hcar.Stop(); } elseif(type==CarType.Bmw) { bcar.Stop(); } } }

分析：這會給系統增加新的相互依賴。隨著時間的推移，越來越多的車種必須加入到AutoSystem中，這個“AutoSystem”模塊將會被if/else語句弄得很亂，而且依賴于很多的低層模塊，只要低層模塊發生變動，AutoSystem就必須跟著變動， 它最終將變得僵化、脆弱。 導致上面所述問題的一個原因是，含有高層策略的模塊，如AutoSystem模塊，依賴于它所控制的低層的具體細節的模塊（如HondaCar()和FordCar()）。如果我們能夠找到一種方法使AutoSystem模塊獨立于它所控制的具體細節，那么我們就可以自由地復用它了。我們就可以用這個模塊來生成其它的程序，使得系統能夠用在需要的汽車上。OOD給我們提供了一種機制來實現這種“依賴倒置”。

4結構圖編輯

圖二 看圖 2中這個簡單的類圖。這兒有一個“AutoSystem”類，它包含一個“ICar”接口。這個“AutoSystem”類根本不依賴于“FordCar”和“HondaCar”。所以，依賴關系被“倒置”了：“AutoSystem”模塊依賴于抽象，那些具體的汽車操作也依賴于相同的抽象。 于是可以添加ICar

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71

publicinterfaceICar { voidRun(); voidTurn(); voidStop(); } publicclassBmwCar:ICar { publicvoidRun() { Console.WriteLine("寶馬開始啟動了"); } publicvoidTurn() { Console.WriteLine("寶馬開始轉彎了"); } publicvoidStop() { Console.WriteLine("寶馬開始停車了"); } } publicclassFordCar:ICar { publicvoidRun() { Console.WriteLine("福特開始啟動了"); } publicvoidTurn() { Console.WriteLine("福特開始轉彎了"); } publicvoidStop() { Console.WriteLine("福特開始停車了"); } } publicclassHondaCar:ICar { publicvoidRun() { Console.WriteLine("本田開始啟動了"); } publicvoidTurn() { Console.WriteLine("本田開始轉彎了"); } publicvoidStop() { Console.WriteLine("本田開始停車了"); } } publicclassAutoSystem { privateICaricar; publicAutoSystem(ICaricar) { this.icar=icar; } privatevoidRunCar() { icar.Run(); } privatevoidTurnCar() { icar.Turn(); } privatevoidStopCar() { icar.Stop(); } }

現在AutoSystem系統依賴于ICar 這個抽象，而與具體的實現細節HondaCar、FordCar、BmwCar無關，所以實現細節的變化不會影響AutoSystem。對于實現細節只要實現ICar 即可，即實現細節依賴于ICar 抽象。 綜上： 一個應用中的重要策略決定及業務模型正是在這些高層的模塊中。也正是這些模型包含著應用的特性。但是，當這些模塊依賴于低層模塊時，低層模塊的修改將會直接影響到它們，迫使它們也去改變。這種境況是荒謬的。應該是處于高 層的模塊去迫使那些低層的模塊發生改變。應該是處于高層的模塊優先于低層的模塊。無論如何高層的模塊也不應依賴于低層的模塊。而且，我們想能夠復用的是高層的模塊。通過子程序庫的形式，我們已經可以很好地復用低層的模塊了。當高層的模塊依賴于低層的模塊時，這些高層模塊就很難在不同的環境中復用。但是，當那些高層模塊獨立于低層模塊時，它們就能很簡單地被復用了。這正是位于框架設計的最核心之處的原則。 總結：依賴倒置原則 A.高層次的模塊不應該依賴于低層次的模塊，他們都應該依賴于抽象。 B.抽象不應該依賴于具體，具體應該依賴于抽象。

轉載于:https://www.cnblogs.com/love828/p/3871999.html

總結

以上是生活随笔為你收集整理的ASP.NET 设计模式中依赖倒置原则的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。