C#編程之依賴倒置原則DIP

更新時(shí)間：2022年03月20日 14:30:27 作者：.NET開發(fā)菜鳥

這篇文章介紹了C#編程之依賴倒置原則DIP，文中通過示例代碼介紹的非常詳細(xì)。對大家的學(xué)習(xí)或工作具有一定的參考借鑒價(jià)值，需要的朋友可以參考下

一、前言

我們先來看看傳統(tǒng)的三層架構(gòu)，如下圖所示：

從上圖中我們可以看到：在傳統(tǒng)的三層架構(gòu)中，層與層之間是相互依賴的，UI層依賴于BLL層，BLL層依賴于DAL層。分層的目的是為了實(shí)現(xiàn)“高內(nèi)聚、低耦合”。傳統(tǒng)的三層架構(gòu)只有高內(nèi)聚沒有低耦合，層與層之間是一種強(qiáng)依賴的關(guān)系，這也是傳統(tǒng)三層架構(gòu)的一種缺點(diǎn)。這種自上而下的依賴關(guān)系會(huì)導(dǎo)致級聯(lián)修改，如果低層發(fā)生變化，可能上面所有的層都需要去修改，而且這種傳統(tǒng)的三層架構(gòu)也很難實(shí)現(xiàn)團(tuán)隊(duì)的協(xié)同開發(fā)，因?yàn)樯蠈庸δ苋Q于下層功能的實(shí)現(xiàn)，下面功能如果沒有開發(fā)完成，則上層功能也無法進(jìn)行。

傳統(tǒng)的三層架構(gòu)沒有遵循依賴倒置原則（DIP）來設(shè)計(jì)，所以就會(huì)出現(xiàn)上面的問題。

二、依賴倒置

依賴倒置(DIP)：Dependence Inversion Principle的縮寫，主要有兩層含義：

高層次的模塊不應(yīng)該依賴低層次的模塊，兩者都應(yīng)該依賴其抽象。
抽象不應(yīng)該依賴于具體，具體應(yīng)該依賴于抽象。

我們先來解釋第一句話：高層模塊不應(yīng)該直接依賴低層模塊的具體實(shí)現(xiàn)，而是應(yīng)該依賴于低層模塊的抽象，也就是說，模塊之間的依賴是通過抽象發(fā)生的，實(shí)現(xiàn)類之間不應(yīng)該發(fā)生直接的依賴關(guān)系，他們的依賴關(guān)系應(yīng)該通過接口或者抽象類產(chǎn)生。

在來解釋第二句話：接口或者抽象類不應(yīng)該依賴于實(shí)現(xiàn)類。舉個(gè)例子，假如我們要寫B(tài)LL層的代碼，直接就去實(shí)現(xiàn)了功能，等到開發(fā)完成以后發(fā)現(xiàn)沒有使用依賴倒置原則，這時(shí)候在根據(jù)實(shí)現(xiàn)類去寫接口，這種是不對的，應(yīng)該首先設(shè)計(jì)抽象，然后在根據(jù)抽象去實(shí)現(xiàn)，應(yīng)該要面向接口編程。

我們在上面說過，在傳統(tǒng)的三層架構(gòu)里面沒有使用依賴倒置原則，那么把依賴倒置原則應(yīng)用到傳統(tǒng)的三層架構(gòu)里面會(huì)如何呢？我們知道，在傳統(tǒng)的三層架構(gòu)里面，UI層直接依賴于BLL層，BLL層直接依賴于DAL層，由于每一層都是依賴下一層的實(shí)現(xiàn)，所以說當(dāng)下層發(fā)生變化的時(shí)候，它的上一層也要發(fā)生變化，這時(shí)候可以根據(jù)依賴倒置原則來重新設(shè)計(jì)三層架構(gòu)。

UI、BLL、DAL三層之間應(yīng)該沒有直接的依賴關(guān)系，都應(yīng)該依賴于接口。首先應(yīng)該先確定出接口，DAL層抽象出IDAL接口，BLL層抽象出IBLL接口，這樣UI層依賴于IBLL接口，BLL實(shí)現(xiàn)IBLL接口。BLL層依賴于IDAL接口，DAL實(shí)現(xiàn)IDAL接口。如下圖所示：

我們上面講了依賴倒置原則，那么依賴倒置原則的目的是什么呢？
有了依賴倒置原則，可以使我們的架構(gòu)更加的穩(wěn)定、靈活，也能更好地應(yīng)對需求的變化。相對于細(xì)節(jié)的多變性，抽象的東西是穩(wěn)定的。所以以抽象為基礎(chǔ)搭建起來的架構(gòu)要比以細(xì)節(jié)為基礎(chǔ)搭建起來的架構(gòu)要穩(wěn)定的多。

在傳統(tǒng)的三層架構(gòu)里面，僅僅增加一個(gè)接口層，我們就實(shí)現(xiàn)了依賴倒置，目的就是降低層與層之間的耦合。有了這樣的接口層，三層架構(gòu)才真正實(shí)現(xiàn)了“高內(nèi)聚、低耦合”的思想。

依賴倒置原則是架構(gòu)層面上的，那么如何在代碼層面上實(shí)現(xiàn)呢？下面看控制反轉(zhuǎn)。

三、控制反轉(zhuǎn)

控制反轉(zhuǎn)(IOC)：Inversion of Control的縮寫，一種反轉(zhuǎn)流、依賴和接口的方式，它把傳統(tǒng)上由程序代碼直接操控的對象的控制器（創(chuàng)建、維護(hù)）交給第三方，通過第三方（IOC容器）來實(shí)現(xiàn)對象組件的裝配和管理。

IOC容器，也可以叫依賴注入框架，是由一種依賴注入框架提供的，主要用來映射依賴，管理對象的創(chuàng)建和生存周期。IOC容器本質(zhì)上就是一個(gè)對象，通常會(huì)把程序里面所有的類都注冊進(jìn)去，使用這個(gè)類的時(shí)候，直接從容器里面去解析。

四、依賴注入

依賴注入(DI)：Dependency Injection的縮寫。依賴注入是控制反轉(zhuǎn)的一種實(shí)現(xiàn)方式，依賴注入的目的就是為了實(shí)現(xiàn)控制反轉(zhuǎn)。

依賴注入是一種工具或手段，目的是幫助我們開發(fā)出松耦合、可維護(hù)的程序。

依賴注入常用的方式有以下幾種：

構(gòu)造函數(shù)注入。
屬性注入。
方法注入。

其中構(gòu)造函數(shù)注入是使用最多的，其次是屬性注入。

看下面的一個(gè)例子：父親給孩子講故事，只要給這個(gè)父親一本書，他就可以照著這本書給孩子講故事。我們下面先用最傳統(tǒng)的方式實(shí)現(xiàn)一下，這里不使用任何的設(shè)計(jì)原則和設(shè)計(jì)模式。

首先定義一個(gè)Book類：

namespace DipDemo1
{
    public class Book
    {
        public string GetContent()
        {
            return "從前有座山，山上有座廟.....";
        }
    }
}

然后在定義一個(gè)Father類：

using System;

namespace DipDemo1
{
    public class Father
    {
        public void Read()
        {
            Book book = new Book();
            Console.WriteLine("爸爸開始給孩子講故事了");
            Console.WriteLine(book.GetContent());
        }
    }
}

然后在Main方法里面調(diào)用：

using System;

namespace DipDemo1
{
    class Program
    {
        static void Main(string[] args)
        {
            Father father = new Father();
            father.Read();
            Console.ReadKey();
        }
    }
}

我們來看看關(guān)系圖：

我們看到：Father是直接依賴于Book類。

這時(shí)需求發(fā)生了變化，不給爸爸書了，給爸爸報(bào)紙，讓爸爸照著報(bào)紙給孩子讀報(bào)紙，這時(shí)該怎么做呢？按照傳統(tǒng)的方式，我們這時(shí)候需要在定義一個(gè)報(bào)紙類：

namespace DipDemo1
{
    public class NewsPaper
    {
        public string GetContent()
        {
            return "新聞";
        }
    }
}

這時(shí)依賴關(guān)系變了，因?yàn)榘职忠蕾囉趫?bào)紙了，這就導(dǎo)致還要修改Father類：

using System;

namespace DipDemo1
{
    public class Father
    {
        public void Read()
        {
            // 讀書
            // Book book = new Book();
            //Console.WriteLine("爸爸開始給孩子講故事了");
            //Console.WriteLine(book.GetContent());

            // 報(bào)紙
            NewsPaper paper = new NewsPaper();
            Console.WriteLine("爸爸開始給孩子講新聞");
            Console.WriteLine(paper.GetContent());
        }
    }
}

假設(shè)后面需求又變了，又不給報(bào)紙了，換成雜志、平板電腦等。需求在不斷的變化，不管怎么變化，對于爸爸來說，他一直在讀讀物，但是具體讀什么讀物是會(huì)發(fā)生變化，這就是細(xì)節(jié)，也就是說細(xì)節(jié)會(huì)發(fā)生變化。但是抽象是不會(huì)變的。如果這時(shí)候還是使用傳統(tǒng)的OOP思想來解決問題，那么會(huì)導(dǎo)致程序不斷的在修改。下面使用工廠模式來優(yōu)化：

首先創(chuàng)建一個(gè)接口：

namespace DipDemo2
{
    public interface IReader
    {
        string GetContent();
    }
}

然后讓Book類和NewsPaper類都繼承自IReader接口，Book類

namespace DipDemo2
{
    public class Book : IReader
    {
        public string GetContent()
        {
            return "從前有座山，山上有座廟.....";
        }
    }
}

NewsPaper類：

namespace DipDemo2
{
    public class NewsPaper : IReader
    {
        public string GetContent()
        {
            return "王聰聰被限制高消費(fèi)......";
        }
    }
}

然后創(chuàng)建一個(gè)工廠類：

namespace DipDemo2
{
    public static class ReaderFactory
    {
        public static IReader GetReader(string readerType)
        {
            if (string.IsNullOrEmpty(readerType))
            {
                return null;
            }

            switch (readerType)
            {
                case "NewsPaper":
                    return new NewsPaper();
                case "Book":
                    return new Book();
                default:
                    return null;
            }
        }
    }
}

里面方法的返回值是一個(gè)接口類型。最后在Father類里面調(diào)用工廠類：

using System;

namespace DipDemo2
{
    public class Father
    {
        private IReader Reader { get; set; }

        public Father(string readerName)
        {
            // 這里依賴于抽象
            Reader = ReaderFactory.GetReader(readerName);
        }

        public void Read()
        {
            Console.WriteLine("爸爸開始給孩子講故事了");
            Console.WriteLine(Reader.GetContent());
        }
    }
}

最后在Main方法里面調(diào)用：

using System;

namespace DipDemo2
{
    class Program
    {
        static void Main(string[] args)
        {
            Father father = new Father("Book");
            father.Read();

            Console.ReadKey();
        }
    }
}

我們這時(shí)候可以在看看依賴關(guān)系圖：

這時(shí)Father已經(jīng)和Book、Paper沒有任何依賴了，F(xiàn)ather依賴于IReader接口，還依賴于工廠類，而工廠類又依賴于Book和Paper類。這里實(shí)際上已經(jīng)實(shí)現(xiàn)了控制反轉(zhuǎn)。Father（高層）不依賴于低層（Book、Paper）而是依賴于抽象（IReader），而且具體的實(shí)現(xiàn)也不是由高層來創(chuàng)建，而是由第三方來創(chuàng)建（這里是工廠類）。但是這里只是使用工廠模式來模擬控制反轉(zhuǎn)，而沒有實(shí)現(xiàn)依賴的注入，依賴還是需要向工廠去請求。

下面繼續(xù)優(yōu)化代碼，這里只需要修改Father類：

using System;

namespace DipDemo3
{
    public class Father
    {
        public IReader Reader { get; set; }

        /// <summary>
        /// 構(gòu)造函數(shù)的參數(shù)是IReader接口類型
        /// </summary>
        /// <param name="reader"></param>
        public Father(IReader reader)
        {
            Reader = reader;
        }

        public void Read()
        {
            Console.WriteLine("爸爸開始給孩子講故事了");
            Console.WriteLine(Reader.GetContent());
        }
    }
}

在Main方法里面調(diào)用：

using System;
namespace DipDemo3
{
    class Program
    {
        static void Main(string[] args)
        {
            var f = new Father(new Book());
            f.Read();

            Console.ReadKey();
        }
    }
}

如果以后換成了Paper，需要修改代碼：

using System;
namespace DipDemo3
{
    class Program
    {
        static void Main(string[] args)
        {
            // Book
            //var f = new Father(new Book());
            //f.Read();

            // Paprer
            var f = new Father(new Paper());
            f.Read();

            Console.ReadKey();
        }
    }
}

由于這里沒有了工廠，我們還是需要在代碼里面實(shí)例化具體的實(shí)現(xiàn)類。如果有一個(gè)IOC容器，我們就不需要自己new一個(gè)實(shí)例了，而是由容器幫我們創(chuàng)建實(shí)例，創(chuàng)建完成以后在把依賴對象注入進(jìn)去。

我們在來看一下依賴關(guān)系圖：

下面我們使用Unity容器來繼續(xù)優(yōu)化上面的代碼，首先需要在項(xiàng)目里面安裝Unity，直接在NuGet里面搜索即可：

這里只需要修改Main方法調(diào)用即可：

using System;
using Unity;

namespace UnityDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            // 創(chuàng)建容器
            var container = new UnityContainer();

            // 掃描程序集、配置文件
            // 在容器里面注冊接口和實(shí)現(xiàn)類，創(chuàng)建依賴關(guān)系
            container.RegisterType<IReader, Book>();

            // 在容器里面注冊Father
            container.RegisterType<Father>();

            // 從容器里拿出要使用的類，容器會(huì)自行創(chuàng)建father對
            // 還會(huì)從容器里去拿到他所依賴的對象，并且注入進(jìn)來
            // 
            var father = container.Resolve<Father>();

            // 調(diào)用方法
            father.Read();
            Console.ReadKey();
        }
    }
}

到此這篇關(guān)于C#編程之依賴倒置原則DIP的文章就介紹到這了。希望對大家的學(xué)習(xí)有所幫助，也希望大家多多支持腳本之家。

您可能感興趣的文章: