依賴倒置（DIP）與依賴注入（DI）

　　依賴倒置原則（Dependency Inversion Principle）為我們提供了降低模組間耦合度的一種思路，依賴注入（Dependency Injection）是一種具體的實施方法。

依賴倒置原則：

　　前面一篇講軟體設計原則的文章中已經提到了“依賴倒置原則”（Dependency Inversion Principle），該原則主要是為了降低模組與模組之間的“耦合度”，提倡模組與模組之間不要發生直接的依賴關係，即：高層模組不應該直接依賴於低層模組，高層模組和低層模組應該同時依賴一個抽象層。如果現在有一個類Manager在處理某一任務時，需要記錄錯誤日誌，那麼我們可以這樣編寫程式碼：

class Manager
{
    //…
    FileLogger _logger;
    public void DoSomething()
    {
        try
        {
            //…do something
        }
        catch(Exception ex)
        {
            if(_logger == null)
            {
                _logger = new FileLogger();
            }
            _logger.Log(ex.ToString())
        }
    }
}
class FileLogger
{
    public void Log(string errorLog)
    {
        //…write into log file
    }
}

如上程式碼所示，FileLogger類負責將錯誤日誌儲存到檔案，Manager類中定義了一個Logger類物件，專門負責記錄錯誤日誌，這段程式碼中的“高層模組”Manager類就直接依賴與“低層模組”FileLogger，如果我們現在需要將錯誤日誌記錄通過Email傳送給別人，或者傳送給別的模組，我們不得不去修改Manager類的程式碼。

　　“依賴倒置原則”建議我們，Manager類不應該直接依賴於FIleLogger類，而應該依賴一個抽象層（介面層），所以原來程式碼應該這樣寫：

class Manager
{
    ILog _logger;
    public void DoSomething()
    {
        try
        {
            
        }
        catch(Exception ex)
        {
            if(_logger == null)
            {
                _logger = new FileLogger();
                // _logger = new EmailLogger();
                //_logger = new NotifyLogger();
            }
            _logger.Log(ex.ToString());
        }
    }
}
interface ILog
{
    void Log(string errorLog);
}
class FileLogger:ILog
{
    public void Log(string errorLog)
    {
        //…write into file
    }
}
class EmailLogger:ILog
{
    public void Log(string errorLog)
    {
        //…send to others as email
    }
}
class NotifyLogger:ILog
{
    public void Log(string errorLog)
    {
        //… notify other modules
    }
}

如上程式碼所示，我們把記錄錯誤日誌的邏輯抽象出來一個ILog介面，Manager類不再依賴於任何一個具體的類，而是依賴於ILog介面，同時我們可以根據ILog介面實現各種各樣的日誌記錄類，如FileLogger將日誌儲存到檔案、EmailLogger將日誌以郵件形式傳送給別人、NotifyLogger將錯誤資訊通知程式中其他模組。這樣以來，整個程式碼的靈活度明顯增加了，如果我們需要將日誌儲存到檔案，直接使用FileLogger，如果我們想將日誌以郵件形式傳送別人，直接使用EmailLogger等等。下圖顯示依賴倒置發生前後：

 

依賴注入：

　　上面的Manager類雖然不再直接依賴任何具體的日誌記錄型別，但是實質上，我們建立記錄日誌類物件還是在Manager內部（catch中），如果我們想換種方式記錄日誌，還是得動Manager類的程式碼，有沒有一種方式，能夠讓我們不需要修改Manager程式碼就能切換日誌的記錄方式呢？當然是有的，“依賴注入”就是這一問題的具體解決方法，我們有三種方式去讓兩個型別發生依賴關係：

（1）構造注入（Constructor Injection）

　　在我們建立Manager物件的時候，將記錄日誌的物件作為構造引數傳遞給新建立的Manager物件，假設Manager有一個帶ILog型別引數的構造方法，如：

class Manager
{
    ILog _logger;
    public Manager(ILog logger)
    {
        _logger = logger;
    }
    //…
}

那麼，我們在建立Manager物件的時候，這樣編寫程式碼：

　　Manager m = new Manager(new FileLogger());

　　//Manager m = new Manager(new EmailLogger());

　　//Manager m = new Manager(new NotifyLogger());

很明顯，這種日誌記錄方式一直不變，對Manager終生有效。

（2）方法注入（Method Injection）

　　為Manager類中每個需要記錄日誌的方法增加一個ILog的引數，比如Manager.DoSomething方法重新定義為：

class Manager
{
    //…
    public void DoSomething(ILog logger)
    {
        try
        {
            //…
        }
        catch(Exception ex)
        {
            logger.Log(ex.ToString());
        }
    }
}

那麼我們之後在使用Manager的時候，每次呼叫方法都應該為它提供一個記錄日誌的物件，如：

　　Manager m = new Manager();

　　m.DoSomething(new FileLogger());

　　m.DoSomething(new EmailLogger());

　　m.DoSomething(new NotifyLogger());

這種記錄日誌的方式，只對當前方法有效，每次呼叫方法都可以不同。

（3）屬性注入（Property Injection）

　　在Manager類中公開一個屬性，用來設定日誌記錄物件，Mananger這樣定義：

class Manager
{
    private ILog _logger;
    public ILog Logger
    {
        get
        {
            return _logger;
        }
        set
        {
            _logger = value;
        }
    }
    //…
}

之後我們使用Mananger時，可以隨時更換它的日誌記錄方式：

　　Mananger m = new Manager();

　　m.Logger = new FileLogger();

　　m.Logger = new EmailLogger();

　　m.Logger = new NotifyLogger();

使用這種方式，我們可以隨時切換記錄日誌的方式，它的靈活度介於“構造注入”和“方法注入”之間。

　　以上三種依賴注入方法可以混合使用，也就是說，你可以為Manager類定義一個帶ILog型別的引數，同時也可以定義一個ILog型別的屬性，或者為每個方法增加一個ILog型別的引數。

　　注：

    【1】在.NET中，“抽象層”可以不使用介面interface去實現，而是直接使用委託，舉一個例子，我們使用FileStream.BeginRead方法時，給它提供的一個AsyncCallback回撥引數，其實就是屬於“方法注入”的一種。

   【2】型別與型別之間不可能完全失去依賴關係，怎樣讓這種非有不可的依賴關係更微弱，是軟體設計的一門高深學問。

 

上一篇設計原則（倒數第二小節）  http://www.cnblogs.com/xiaozhi_5638/p/3610706.html