1、依賴倒置（Dependency Inversion Principle）
依賴倒置是面向對象設計領域的一種軟件設計原則。（其餘的設計原則還有：單一職責原則、開放封閉原則、裏式替換原則、接口分離原則，合稱SOLID）html
話說設計原則有什麼用呢？
設計原則是無數編程前輩總結下來的經驗，好似編程界的金科玉律。在我看來就像是武俠小說中武林祕籍，內功心法。熟練掌握設計原則，一定會在編程道路上順風順水，獨霸一方。編程
言歸正傳，依賴倒置原則，依賴指的是什麼？倒置又是什麼呢？
先說說依賴，依賴是一種關係，A在某種狀況下存在對B的需求關係，咱們就能夠看做A依賴B。設計模式
在生活中，魚依賴於水而生存，水被魚依賴；程序中，業務層依賴邏輯層，邏輯層依賴於數據層...架構
咱們用面向對象編程來展現一下上面依賴關係：ide
/// <summary>
/// 河水
/// </summary>
public class RiverWater
{
public void GiveNutrition()
{
Console.WriteLine("我是河水，我給小魚提供營養。");
}
}
/// <summary>
/// 魚
/// </summary>
public class Fish
{
private RiverWater riverWater;
public void Live()
{
riverWater = new RiverWater();
riverWater.GiveNutrition();
}
}
Fish內部存在對RiverWater的引用，也就是說Fish 依賴於RiverWarter。函數
依賴關係整明白了，咱們再來看看依賴倒置原則的定義：（敲黑板，劃重點）post
1.上層模塊不該該依賴底層模塊，它們都應該依賴於抽象。 2.抽象不該該依賴於細節，細節應該依賴於抽象。
問題又來了，什麼是上層模塊和底層模塊？
對於任何一個組織機構而言，它必定有架構的設計，有職能的劃分。按照職能的重要性，天然而然就有了上下之分。而且，隨着模塊的粒度劃分不一樣這種上層與底層模塊會進行變更，也許某一模塊相對於另一模塊它是底層，可是相對於其餘模塊它又多是上層。拿一個公司架構來看，管理層就是上層，管理層之下就是底層。而後，咱們再以部門爲體系劃分，各個部門經理以上部分是上層，之下的組織均可以稱爲底層。學習
由此，咱們能夠看到，在一個特定體系中，上層模塊與底層模塊能夠按照決策能力高低爲準繩進行劃分。編碼
映射到咱們軟件實際開發中，通常咱們也會將軟件進行模塊劃分，好比業務層、邏輯層和數據層。 業務層中是軟件真正要進行的操做，也就是作什麼；邏輯層是軟件現階段爲了業務層的需求提供的實現細節，也就是怎麼作；數據層指業務層和邏輯層所須要的數據模型。url
所以，按照決策能力的高低進行模塊劃分。業務層天然就處於上層模塊，邏輯層和數據層天然就歸類爲底層。
什麼是抽象和細節？
抽象就是對一類事物或行爲的歸納，總結其共性。抽象每每是相對具體而言，具體也就是這裏的細節。好比：人是抽象，張3、李四就是具體；水是抽象，河水，井水就是具體的；武功祕籍是抽象的，獨孤九劍，葵花寶典是具體的；運動是抽象的，跑步，游泳是具體的...
映射到軟件開發中，抽象能夠是接口或者抽象類的形式：
public abstract class Water
{
public abstract void GiveNutrition();
}
/// <summary>
/// 河水
/// </summary>
public class RiverWater : Water
{
public override void GiveNutrition()
{
Console.WriteLine("河水-提供營養。");
}
}
/// <summary>
/// 井水
/// </summary>
public class WellWater : Water
{
public override void GiveNutrition()
{
Console.WriteLine("井水-提供營養。");
}
}
Warter是抽象類，是抽象的，RiverWarter、WellWater繼承了Water，它們是具體的。
如今，搞清楚了上層模塊、底層模塊、抽象和具體。能夠正式開始學習依賴倒置原則這個概念了。
先來看看咱們平時開發的編碼邏輯：
/// <summary>
/// 魚
/// </summary>
public class Fish
{
private RiverWater riverWater;
public Fish()
{
riverWater = new RiverWater();
}
public void Live()
{
Console.WriteLine("個人生活靠：");
riverWater.GiveNutrition();
}
}
咱們建立了一條小魚fish，它的生活靠河水riverWater。
class Program
{
static void Main(string[] args)
{
Fish fish = new Fish();
fish.Live();
}
}
執行結果：
有一天，河水乾涸了，小魚的生活要靠井水wellWater。因而代碼就要修改
/// <summary>
/// 魚
/// </summary>
public class Fish
{
private RiverWater riverWater;
private WellWater wellWater;
public Fish()
{
//riverWater = new RiverWater();
wellWater = new WellWater();
}
public void Live()
{
Console.WriteLine("個人生活靠：");
//riverWater.GiveNutrition();
wellWater.GiveNutrition();
}
}
咱們就要修改Fish類的代碼。哪天，小魚游到了湖水lakeWater裏。代碼又要修改
/// <summary>
/// 湖水
/// </summary>
public class LakeWater : Water
{
public override void GiveNutrition()
{
Console.WriteLine("湖水-提供營養。");
}
}
/// <summary>
/// 魚
/// </summary>
public class Fish
{
private RiverWater riverWater;
private WellWater wellWater;
private LakeWater lakeWater;
public Fish()
{
//riverWater = new RiverWater();
//wellWater = new WellWater();
lakeWater = new LakeWater();
}
public void Live()
{
Console.WriteLine("個人生活靠：");
//riverWater.GiveNutrition();
//wellWater.GiveNutrition();
lakeWater.GiveNutrition();
}
}
咱們添加了LakeWater這個新的實現類，再次修改Fish類。
這是最基礎的演示代碼，若是工程大了，代碼複雜了，Fish面對需求變更時改動的地方會更多。那麼問題來了：
有沒有方法讓Fish類變更的少一些？
依賴倒置原則正好適用於解決這類狀況。下面，咱們嘗試運用依賴倒置原則對代碼進行改造。
首先是上層模塊和底層模塊的拆分。按照決策能力高低或者重要性劃分，Fish屬於上層模塊，RiverWater、WellWater 和 LakeWater 屬於底層模塊。
上層模塊不該該依賴於底層模塊。 Fish 這個類顯然是依賴於 RiveWater/WellWater/LakeWater。Fish 類中 Live() 的能力徹底依賴於屬性riveWater/wellWater/lakeWater 對象。
上層和底層都應該依賴於抽象。所以咱們要引入抽象——Water類。Fish類中 Live() 這個方法依賴於 Water的抽象方法，它沒有限定營養的提供方式，任何 RiverWater、WellWater 或者是 LakeWater 均可以的。
/// <summary>
/// 魚
/// </summary>
public class Fish
{
private Water water;
public Fish()
{
water = new LakeWater();
}
public void Live()
{
Console.WriteLine("個人生活靠：");
warter.GiveNutrition();
}
}
運行結果：
到這一步，咱們能夠說是符合了上層不依賴於底層，依賴於抽象的準則了。
最後來講說我對倒置的理解：在未使用依賴倒置原則編碼之前，魚依賴具體的河水/井水，河水/井水是被依賴的。使用依賴倒置之後，魚依賴於抽象的水，具體的河水/井水再也不被依賴，反而它們要求實現抽象的水（細節依賴於抽象），這種依賴關係的改變稱之爲倒置。
2、控制反轉（Inversion Of Control）
控制反轉(IOC)意思是對控制權的反轉。
那麼控制權指的是什麼？又是怎麼反轉的？
以上面的例子來講,魚(Fish類)依賴於水(Water類)，因此Fish類內部控制着Water類的實例建立，這種方式能夠理解爲控制正轉。雖然魚已經依賴於抽象的水，Live()方法不會再由於生活水域的改變而改變，但水域變化時，咱們仍是要修改Fish類：
==>
如今咱們改變這種方式，將Water類的實例化移到Fish外面：
/// <summary>
/// 魚
/// </summary>
public class Fish
{
private Water water;
public Fish(Water _water)
{
water = _water;
}
public void Live()
{
Console.WriteLine("個人生活靠：");
water.GiveNutrition();
}
}
class Program
{
static void Main(string[] args)
{
Water water = new RiverWater();
Fish fish = new Fish(water);
fish.Live();
Console.ReadKey();
}
}
這樣，不論水域怎麼變化，Fish 列都不須要修改了。Fish 把內部依賴的建立權力移交給了 Program 這個類中的 Main() 方法。也就是說 Fish 只關心依賴提供的功能，但並不關心依賴的建立。
這種思想其實就是 IOC，IOC 是一種新的設計模式，它對上層模塊與底層模塊進行了更進一步的解耦。控制反轉的意思是反轉了上層模塊對於底層模塊的依賴控制。好比上面代碼，Fish 再也不親自建立 Water 對象，它將依賴的實例化的權力交接給了 Program。而 Program 在 IOC 中又指代了 IOC 容器 這個概念。
IOC 模式最核心的地方就是在於依賴方與被依賴方之間，也就是上文中說的上層模塊與底層模塊之間引入了第三方，這個第三方統稱爲 IOC 容器，由於 IOC 容器的介入，致使上層模塊對於它的依賴的實例化控制權發生變化，也就是所謂的控制反轉的意思。
3、依賴注入（Dependency Injection）
依賴注入(DI)，它是實現IOC的實現方式，動態地將某種依賴關係注入到對象之中。
回顧上面的例子，Fish 不在實例化建立Water，它就須要在外部（IOC 容器）賦值給它，這個賦值的動做有個專門的術語叫作注入（injection）。相似於，魚生活在魚缸裏了，外接一個水龍頭，水龍頭另外一頭鏈接着水塔，這個水塔就比如是IOC容器，魚不用關心生活在什麼水裏了，須要水時，打開水龍頭（注入）就行了，至於水塔裏裝的是河水、井水仍是海水，都不用考慮。
實現依賴注入有 3 種方式：
1. 構造函數中注入
public class Fish
{
private Water water;
public Fish(Water _water)
{
water = _water;
}
public void Live()
{
Console.WriteLine("個人生活靠：");
water.GiveNutrition();
}
}
優勢：在 Person 一開始建立的時候就肯定好了依賴。
缺點：後期沒法更改依賴。
2. setter 方式注入
public class Fish
{
private Water water;
public Fish()
{
}
public void setWater(Water _water)
{
water = _water;
}
public void Live()
{
if (water != null)
{
Console.WriteLine("個人生活靠：");
water.GiveNutrition();
}
}
}
優勢：Fish 對象在運行過程當中能夠靈活地更改依賴。
缺點：Fish 對象運行時，可能會存在依賴項爲 null 的狀況，因此須要檢測依賴項的狀態
3. 接口注入
public class Fish : ISetWater
{
private Water water;
public Fish()
{
}
public void Live()
{
if (water != null)
{
Console.WriteLine("個人生活靠：");
water.GiveNutrition();
}
}
public void SetWater(Water _water)
{
water = _water;
}
}
public interface ISetWater
{
void SetWater(Water water);
}
這種方式和 Setter 方式很類似，接口的存在，代表了一種依賴配置的能力。好比，魚有 活魚和死魚，接口注入方式，咱們就能夠控制，只給活魚注入配置。
4、總結
- 依賴倒置是面向對象開發領域中的軟件設計原則，它倡導上層模塊不依賴於底層模塊，抽象不依賴細節。
- 依賴反轉是遵照依賴倒置這個原則而提出來的一種設計模式，它引入了 IoC 容器的概念。
- 依賴注入是爲了實現依賴反轉的一種手段之一。
- 它們的本質是爲了代碼更加的「高內聚,低耦合」。
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace 引入依賴倒置 { public abstract class Water { public abstract void GiveNutrition(); } /// <summary> /// 河水 /// </summary> public class RiverWater : Water { public override void GiveNutrition() { Console.WriteLine("河水-提供營養。"); } } /// <summary> /// 井水 /// </summary> public class WellWater : Water { public override void GiveNutrition() { Console.WriteLine("井水-提供營養。"); } } /// <summary> /// 魚 /// </summary> public class Fish { private RiverWater riverWater; private WellWater wellWater; public Fish() {//Fish內部存在對RiverWater的引用，也就是說Fish 依賴於RiverWarter。 //riverWater = new RiverWater(); wellWater = new WellWater(); } public void Live() { Console.WriteLine("個人生活靠："); //riverWater.GiveNutrition(); wellWater.GiveNutrition(); } } public class LakeWater : Water { public override void GiveNutrition() { Console.WriteLine("湖水-提供營養。"); } } class Program { static void Main(string[] args) { Fish fish = new Fish(); fish.Live(); //小魚的生活要靠井水wellWater。因而代碼就要修改 //代碼又要修改 //咱們添加了LakeWater這個新的實現類，再次修改Fish類。 //這是最基礎的演示代碼，若是工程大了，代碼複雜了，Fish面對需求變更時改動的地方會更多。那麼問題來了： //有沒有方法讓Fish類變更的少一些？ //依賴倒置原則正好適用於解決這類狀況。下面，咱們嘗試運用依賴倒置原則對代碼進行改造。 //首先是上層模塊和底層模塊的拆分。按照決策能力高低或者重要性劃分，Fish屬於上層模塊，RiverWater、WellWater 和 LakeWater 屬於底層模塊。 //上層模塊不該該依賴於底層模塊。 Fish 這個類顯然是依賴於 RiveWater/WellWater/LakeWater。Fish 類中 Live() 的能力徹底依賴於屬性riveWater/wellWater/lakeWater 對象。 //上層和底層都應該依賴於抽象。所以咱們要引入抽象——Water類。Fish類中 Live() 這個方法依賴於 Water的抽象方法，它沒有限定營養的提供方式，任何 RiverWater、WellWater 或者是 LakeWater 均可以的。 } } }
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace 依賴倒置 { //依賴倒置是面向對象設計領域的一種軟件設計原則。（其餘的設計原則還有：單一職責原則、開放封閉原則、裏式替換原則、接口分離原則，合稱SOLID） //依賴是一種關係，A在某種狀況下存在對B的需求關係，咱們就能夠看做A依賴B。 //魚依賴於水而生存，水被魚依賴；程序中，業務層依賴邏輯層，邏輯層依賴於數據層... /// <summary> /// 魚 /// </summary> public class Fish { private Water water; public Fish() { //減小修改 複用 water = new LakeWater(); } //private RiverWater riverWater; public void Live() //依賴倒置 {//Fish內部存在對RiverWater的引用，也就是說Fish 依賴於RiverWarter。 Console.WriteLine("個人生活靠："); water.GiveNutrition(); } //上層不依賴於底層 依賴於抽象的準則了。 依賴water //最後來講說我對倒置的理解：在未使用依賴倒置原則編碼之前，魚依賴具體的河水/井水，河水/井水是被依賴的。使用依賴倒置之後，魚依賴於抽象的水，具體的河水/井水再也不被依賴，反而它們要求實現抽象的水（細節依賴於抽象），這種依賴關係的改變稱之爲倒置。 // 1.上層模塊不該該依賴底層模塊，它們都應該依賴於抽象。 //2.抽象不該該依賴於細節，細節應該依賴於抽象。 } public abstract class Water { public abstract void GiveNutrition(); } public class RiverWater : Water { public override void GiveNutrition() { Console.WriteLine("河水-提供營養。"); } } public class LakeWater : Water { public override void GiveNutrition() { Console.WriteLine("湖水-提供營養。"); } } public class WellWater : Water { public override void GiveNutrition() { Console.WriteLine("井水-提供營養。"); } } //Warter是抽象類，是抽象的，RiverWarter、WellWater繼承了Water，它們是具體的。 //如今，搞清楚了上層模塊、底層模塊、抽象和具體。能夠正式開始學習依賴倒置原則這個概念了。 class Program { static void Main(string[] args) { Fish F = new Fish(); F.Live(); } } }
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace 控制反轉 { public abstract class Water { public abstract void GiveNutrition(); } /// <summary> /// 河水 /// </summary> public class RiverWater : Water { public override void GiveNutrition() { Console.WriteLine("河水-提供營養。"); } } public class LakeWater : Water { public override void GiveNutrition() { Console.WriteLine("湖水-提供營養。"); } } /// <summary> /// 井水 /// </summary> public class WellWater : Water { public override void GiveNutrition() { Console.WriteLine("井水-提供營養。"); } } public class Fish { private Water water; public Fish(Water _water) { //water = new LakeWater(); water = _water; } //如今咱們改變這種方式，將Water類的實例化移到Fish外面： public void Live() { Console.WriteLine("個人生活靠："); water.GiveNutrition(); } } class Program { static void Main(string[] args) { // 控制反轉(IOC)意思是對控制權的反轉。 //以上面的例子來講,魚(Fish類)依賴於水(Water類)，因此Fish類內部控制着Water類的實例建立，這種方式能夠理解爲控制正轉。雖然魚已經依賴於抽象的水，Live()方法不會再由於生活水域的改變而改變，但水域變化時，咱們仍是要修改Fish類： Water water = new RiverWater(); Fish fish = new Fish(water); fish.Live(); Console.ReadKey(); //這樣，不論水域怎麼變化，Fish 列都不須要修改了。Fish 把內部依賴的建立權力移交給了 Program 這個類中的 Main() 方法。也就是說 Fish 只關心依賴提供的功能，但並不關心依賴的建立。 //這種思想其實就是 IOC，IOC 是一種新的設計模式，它對上層模塊與底層模塊進行了更進一步的解耦。控制反轉的意思是反轉了上層模塊對於底層模塊的依賴控制。好比上面代碼，Fish 再也不親自建立 Water 對象，它將依賴的實例化的權力交接給了 Program。而 Program 在 IOC 中又指代了 IOC 容器 這個概念。 //IOC 模式最核心的地方就是在於依賴方與被依賴方之間，也就是上文中說的上層模塊與底層模塊之間引入了第三方，這個第三方統稱爲 IOC 容器，由於 IOC 容器的介入，致使上層模塊對於它的依賴的實例化控制權發生變化，也就是所謂的控制反轉的意思。 //業務層天然就處於上層模塊，邏輯層和數據層天然就歸類爲底層 //管理層就是上層，管理層之下就是底層 } } }
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace 依賴注入 { public abstract class Water { public abstract void GiveNutrition(); } /// <summary> /// 河水 /// </summary> public class RiverWater : Water { public override void GiveNutrition() { Console.WriteLine("河水-提供營養。"); } } public class LakeWater : Water { public override void GiveNutrition() { Console.WriteLine("湖水-提供營養。"); } } /// <summary> /// 井水 /// </summary> public class WellWater : Water { public override void GiveNutrition() { Console.WriteLine("井水-提供營養。"); } } //實現依賴注入有 3 種方式： //構造函數中注入 //優勢：在 Person 一開始建立的時候就肯定好了依賴。 //缺點：後期沒法更改依賴。 public class Fish { private Water water; public Fish(Water _water) { water = _water; } public void Live() { Console.WriteLine("個人生活靠："); water.GiveNutrition(); } } //2. setter 方式注入 //優勢：Fish 對象在運行過程當中能夠靈活地更改依賴。 //缺點：Fish 對象運行時，可能會存在依賴項爲 null 的狀況，因此須要檢測依賴項的狀態 public class Fish2 { private Water water; public Fish2() { } public void setWater(Water _water) { water = _water; } public void Live() { if (water != null) { Console.WriteLine("個人生活靠："); water.GiveNutrition(); } } } //3. 接口注入 //這種方式和 Setter 方式很類似，接口的存在，代表了一種依賴配置的能力。好比，魚有 活魚和死魚，接口注入方式，咱們就能夠控制，只給活魚注入配置。 public class Fish3 : ISetWater { private Water water; public Fish3() { } public void Live() { if (water != null) { Console.WriteLine("個人生活靠："); water.GiveNutrition(); } } public void SetWater(Water _water) { water = _water; } } public interface ISetWater { void SetWater(Water water); } class Program { static void Main(string[] args) { Water w = new RiverWater(); Fish f = new Fish(w); f.Live(); Water w2 = new RiverWater(); Fish2 f2 = new Fish2(); f2.setWater(w2); f2.Live(); Water w3 = new RiverWater(); Fish3 f3 = new Fish3(); f3.SetWater(w3); f3.Live(); //依賴注入(DI)，它是實現IOC的實現方式，動態地將某種依賴關係注入到對象之中。 //回顧上面的例子，Fish 不在實例化建立Water，它就須要在外部（IOC 容器）賦值給它，這個賦值的動做有個專門的術語叫作注入（injection）。相似於，魚生活在魚缸裏了，外接一個水龍頭，水龍頭另外一頭鏈接着水塔，這個水塔就比如是IOC容器，魚不用關心生活在什麼水裏了，須要水時，打開水龍頭（注入）就行了，至於水塔裏裝的是河水、井水仍是海水，都不用考慮。 //依賴倒置是面向對象開發領域中的軟件設計原則，它倡導上層模塊不依賴於底層模塊，抽象不依賴細節。 //依賴反轉是遵照依賴倒置這個原則而提出來的一種設計模式，它引入了 IoC 容器的概念。 //依賴注入是爲了實現依賴反轉的一種手段之一。 //它們的本質是爲了代碼更加的「高內聚,低耦合」。 } } }