碼上快樂

相關內容    簡體    繁體

學習Unity -- 理解依賴注入（IOC）三種方式依賴注入

本文轉載自   查看原文   2019-03-09 21:46   782    IOC

IOC:英文全稱：Inversion of Control，中文名稱：控制反轉，它還有個名字叫依賴注入（Dependency Injection）。
作用：將各層的對象以松耦合的方式組織在一起，解耦，各層對象的調用完全面向接口。當系統重構的時候，代碼的改寫量將大大減少。
理解依賴注入：
    當一個類的實例需要另一個類的實例協助時，在傳統的程序設計過程中，通常有調用者來創建被調用者的實例。然而采用依賴注入的方式，創建被調用者的工作不再由調用者來完成，因此叫控制反轉，創建被調用者的實例的工作由IOC容器來完成，然后注入調用者，因此也稱為依賴注入。
舉個有意思的例子（來源於互聯網）

假如我們要設計一個Girl和一個Boy類，其中Girl有Kiss方法，即Girl想要Kiss一個Boy，首先問題是Girl如何認識Boy？
    在我們中國常見的MM認識GG的方式有以下幾種：
    A 青梅竹馬    B 親友介紹   C 父母包辦
    哪一種是最好的？

1.青梅竹馬：很久很久以前，有個有錢的地主家的一閨女叫Lily，她老爸把她許配給縣太爺的兒子Jimmy，屬於指腹為婚，Lily非常喜歡kiss,但是只能kiss Jimmy

[csharp]  view plain copy
 
  1. public class Lily{  
  2.         public Jimmy jimmy;   
  3.         public Girl()  
  4.         {  
  5.             jimmy=new Jimmy();  
  6.         }  
  7.         public void Kiss()  
  8.         {  
  9.             jimmy.Kiss();  
  10.         }  
  11.     }  
  12.   
  13.     public class Jimmy  
  14.     {  
  15.         public void Kiss()  
  16.         {  
  17.             Console.WriteLine("kissing");  
  18.         }  
  19.     }  

這樣導致Lily對Jimmy的依賴性非常強，緊耦合。

2.親友介紹：經常Kiss同一個人令Lily有些厭惡了，她想嘗試新人，於是與Jimmy分手了，通過親朋好友（中間人）來介紹

[csharp]  view plain copy
  1. public class Lily{  
  2.         public Boy boy;   
  3.   
  4.         public Girl()  
  5.         {  
  6.             boy=BoyFactory.createBoy();  
  7.         }  
  8.         public void Kiss()  
  9.         {  
  10.             boy.Kiss();  
  11.         }  
  12.     }  


親友介紹，固然是好。如果不滿意，盡管另外換一個好了。但是，親友BoyFactory經常是以Singleton的形式出現，不然就是，存在於Globals，無處不在，無處不能。實在是太繁瑣了一點，不夠靈活。我為什么一定要這個親友摻和進來呢？為什么一定要付給她介紹費呢？萬一最好的朋友愛上了我的男朋友呢？

 

3.父母包辦：一切交給父母，自己不用非吹灰之力，Lily在家只Kiss

[csharp]  view plain copy
  1. public class Lily{  
  2.         public Boy boy;   
  3.         public Girl(Boy boy)  
  4.         {  
  5.             this.boy=boy;  
  6.         }  
  7.         public void Kiss()  
  8.         {  
  9.             this.boy.Kiss();  
  10.         }  
  11.     }  

 

 

Well，這是對Girl最好的方法，只要想辦法賄賂了Girl的父母，並把Boy交給他。那么我們就可以輕松的和Girl來Kiss了。看來幾千年傳統的父母之命還真是有用哦。至少Boy和Girl不用自己瞎忙乎了。這就是IOC，將對象的創建和獲取提取到外部。由外部容器提供需要的組件。

在設計模式中我們應該還知道依賴倒轉原則，應是面向接口編程而不是面向功能實現，好處是：多實現可以任意切換，我們的Boy應該是實現Kissable接口。這樣一旦Girl不想kiss可惡的Boy的話，還可以kiss可愛的kitten和慈祥的grandmother

好在.net中微軟有一個輕量級的IoC框架Unity，支持構造器注入，屬性注入，方法注入如下圖所示

具體使用方法如下圖所示

[csharp]  view plain copy
  1. using System;  
  2.   
  3. using Microsoft.Practices.Unity;  
  4.   
  5.   
  6. namespace ConsoleApplication9  
  7. {  
  8.     class Program  
  9.     {  
  10.         static void Main(string[] args)  
  11.         {  
  12.             //創建容器  
  13.             IUnityContainer container=new UnityContainer();  
  14.             //注冊映射  
  15.             container.RegisterType<IKiss, Boy>();  
  16.             //得到Boy的實例  
  17.             var boy = container.Resolve<IKiss>();  
  18.              
  19.             Lily lily = new Lily(boy);  
  20.             lily.kiss();  
  21.         }  
  22.     }  
  23.   
  24.   
  25.     public interface IKiss  
  26.     {  
  27.         void kiss();  
  28.     }  
  29.       
  30.   
  31.     public class Lily:IKiss  
  32.     {  
  33.   
  34.         public IKiss boy;   
  35.   
  36.         public Lily(IKiss boy)  
  37.         {  
  38.             this.boy=boy;  
  39.         }  
  40.         public void kiss()  
  41.         {  
  42.             boy.kiss();  
  43.             Console.WriteLine("lily kissing");  
  44.         }  
  45.     }  
  46.   
  47.     public class Boy : IKiss  
  48.     {  
  49.         public void kiss()  
  50.         {  
  51.             Console.WriteLine("boy kissing");  
  52.         }  
  53.     }  
  54. }  

如果采用配置文件注冊的話

[html]  view plain copy
  1. <?xml version="1.0" encoding="utf-8" ?>  
  2. <configuration>  
  3.   <configSections>  
  4.     <section name="unity" type="Microsoft.Practices.Unity.Configuration.UnityConfigurationSection,Microsoft.Practices.Unity.Configuration"/>  
  5.   </configSections>  
  6.   <unity>  
  7.     <containers>  
  8.       <container name="defaultContainer">  
  9.         <register type="命名空間.接口類型1,命名空間" mapTo="命名空間.實現類型1,命名空間" />  
  10.         <register type="命名空間.接口類型2,命名空間" mapTo="命名空間.實現類型2,命名空間" />  
  11.       </container>  
  12.     </containers>  
  13.   </unity>  
  14. </configuration>  


配置的后台代碼：

[csharp]  view plain copy
  1. UnityConfigurationSection configuration = ConfigurationManager.GetSection(UnityConfigurationSection.SectionName)  
  2.             as UnityConfigurationSection;  
  3. configuration.Configure(container, "defaultContainer");  

可以通過方法ResolveAll來得到所有注冊對象的實例：
var Instances = container.Resolve<IKiss>();

Martin Fowler在那篇著名的文章《Inversion of Control Containers and the Dependency Injection pattern》中將具體依賴注入划分為三種形式，即構造器注入、屬性（設置）注入和接口注入,習慣將其划分為一種（類型）匹配和三種注入：

  • 類型匹配（Type Matching）：雖然我們通過接口（或者抽象類）來進行服務調用，但是服務本身還是實現在某個具體的服務類型中，這就需要某個類型注冊機制來解決服務接口和服務類型之間的匹配關系；
  • 構造器注入（Constructor Injection）：IoC容器會智能地選擇選擇和調用適合的構造函數以創建依賴的對象。如果被選擇的構造函數具有相應的參數，IoC容器在調用構造函數之前解析注冊的依賴關系並自行獲得相應參數對象；
  • 屬性注入（Property Injection）：如果需要使用到被依賴對象的某個屬性，在被依賴對象被創建之后，IoC容器會自動初始化該屬性；
  • 方法注入（Method Injection）：如果被依賴對象需要調用某個方法進行相應的初始化，在該對象創建之后，IoC容器會自動調用該方法。

 

 

我們創建一個控制台程序，定義如下幾個接口（IA、IB、IC和ID）和它們各自的實現類（A、B、C、D）。在類型A中定義了3個屬性B、C和D，其類型分別為接口IB、IC和ID。其中屬性B在構在函數中被初始化，以為着它會以構造器注入的方式被初始化；屬性C上應用了DependencyAttribute特性，意味着這是一個需要以屬性注入方式被初始化的依賴屬性；屬性D則通過方法Initialize初始化，該方法上應用了特性InjectionMethodAttribute，意味着這是一個注入方法在A對象被IoC容器創建的時候會被自動調用。

[csharp]  view plain copy
  1. public interface IA { }  
  2.     public interface IB { }  
  3.     public interface IC { }  
  4.     public interface ID { }  
  5.   
  6.     public class A : IA  
  7.     {  
  8.         public IB B { get; set; }  
  9.         [Dependency]  
  10.         public IC C { get; set; }  
  11.         public ID D { get; set; }  
  12.   
  13.         public A(IB b)  
  14.         {  
  15.             this.B = b;  
  16.         }  
  17.         [InjectionMethod]  
  18.         public void Initalize(ID d)  
  19.         {  
  20.             this.D = d;  
  21.         }  
  22.     }  
  23.     public class B : IB { }  
  24.     public class C : IC { }  
  25.     public class D : ID { }  


然后我們為該應用添加一個配置文件，並定義如下一段關於Unity的配置。這段配置定義了一個名稱為defaultContainer的Unity容器，並在其中完成了上面定義的接口和對應實現類之間映射的類型匹配。

[html]  view plain copy
  1. <?xml version="1.0" encoding="utf-8" ?>  
  2. <configuration>  
  3.   <configSections>  
  4.     <section name="unity" type="Microsoft.Practices.Unity.Configuration.UnityConfigurationSection,Microsoft.Practices.Unity.Configuration"/>  
  5.   </configSections>  
  6.   <unity>  
  7.     <containers>  
  8.       <container name="defaultContainer">  
  9.         <register type="UnityDemo.IA,UnityDemo" mapTo="UnityDemo.A, UnityDemo"/>  
  10.         <register type="UnityDemo.IB,UnityDemo" mapTo="UnityDemo.B, UnityDemo"/>  
  11.         <register type="UnityDemo.IC,UnityDemo" mapTo="UnityDemo.C, UnityDemo"/>  
  12.         <register type="UnityDemo.ID,UnityDemo" mapTo="UnityDemo.D, UnityDemo"/>  
  13.       </container>  
  14.     </containers>  
  15.   </unity>  
  16. </configuration>  


最后在Main方法中創建一個代表IoC容器的UnityContainer對象，並加載配置信息對其進行初始化。然后調用它的泛型的Resolve方法創建一個實現了泛型接口IA的對象。最后將返回對象轉變成類型A，並檢驗其B、C和D屬性是否是空

[csharp]  view plain copy
  1. class Program  
  2.     {  
  3.         static void Main(string[] args)  
  4.         {  
  5.             UnityContainer container = new UnityContainer();  
  6.             UnityConfigurationSection configuration = ConfigurationManager.GetSection(UnityConfigurationSection.SectionName) as UnityConfigurationSection;  
  7.             configuration.Configure(container, "defaultContainer");  
  8.             A a = container.Resolve<IA>() as A;  
  9.             if (null!=a)  
  10.             {  
  11.                 Console.WriteLine("a.B==null?{0}",a.B==null?"Yes":"No");  
  12.                 Console.WriteLine("a.C==null?{0}", a.C == null ? "Yes" : "No");  
  13.                 Console.WriteLine("a.D==null?{0}", a.D == null ? "Yes" : "No");  
  14.             }  
  15.         }  
  16.     }  


從如下給出的執行結果我們可以得到這樣的結論：通過Resolve<IA>方法返回的是一個類型為A的對象，該對象的三個屬性被進行了有效的初始化。這個簡單的程序分別體現了接口注入（通過相應的接口根據配置解析出相應的實現類型）、構造器注入（屬性B）、屬性注入（屬性C）和方法注入（屬性D）

  a.B == null ? No
 a.C == null ? No
 a.D == null ? No

 

 

出處：https://www.cnblogs.com/zhangchenliang/archive/2013/01/08/2850970.html

https://www.cnblogs.com/artech/archive/2011/09/15/UnityDemo.html


免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。



猜您在找 理解依賴注入（IOC）和學習Unity spring IOC中三種依賴注入方式 spring的ioc依賴注入的三種方法(xml方式) 依賴注入的三種方式 三種依賴注入的方式 簡單理解.net 依賴注入的三種方式 IoC 依賴注入容器 Unity 依賴注入(DI)的三種實現方式 依賴注入的三種方式以及優缺點。 Spring依賴注入（DI）的三種方式
 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM