LYWILL设计运营 - 网站运营与推广、开发技术、成功项目展示。

Spring.NET如何解耦合（依赖注入）

        谈到设计模式，我们就会说道怎么样解耦合。而Spring.NET的IoC容器其中的一种用途就是解耦合，其最经典的应用就是：依赖注入(Dependeny Injection)简称DI,目前DI是最优秀的解耦方式之一。

　　下面模拟三种不同的场景，可以一起学习使用依赖注入的重要性。

　　下面是应用场景的条件：人类使用工具劳动。

   
C#代码
  1. /// <summary>   
  2. /// 抽象人类   
  3. /// </summary>   
  4. public abstract class Person   
  5. {   
  6.     /// <summary>   
  7.     /// 使用工具劳动   
  8.     /// </summary>   
  9.     public abstract void Work();   
  10. }   
  11.   
  12. public interface ITool   
  13. {   
  14.     /// <summary>   
  15.     /// 使用工具   
  16.     /// </summary>   
  17.     void UseTool();   
  18. }   

 

　　场景一，原始社会：原始人使用长矛打猎

C#代码
  1. public class Spear : ITool   
  2. {   
  3.     public void UseTool()   
  4.     {   
  5.         Console.WriteLine("使用长矛");   
  6.     }   
  7. }   
  8.   
  9.   
  10. public class PrimitivePerson : Person   
  11. {   
  12.     /// <summary>   
  13.     /// 原始社会使用长矛打猎   
  14.     /// </summary>   
  15.     public override void Work()   
  16.     {   
  17.         //知道打猎使用的是长矛，并且制造长矛   
  18.         ITool tool = new Spear();   
  19.         tool.UseTool();   
  20.         Console.WriteLine("使用长矛打猎");   
  21.     }   
  22. }   

 

   

        从上面代码我们不难看出，虽然使用的经典的里氏替换原则，但PrimitivePerson类于Spear类存在着耦合。

　　场景二，经济社会：使用工具耕作

C#代码
  1. public class Hoe : ITool   
  2. {   
  3.     public void UseTool()   
  4.     {   
  5.         Console.WriteLine("使用锄头");   
  6.     }   
  7. }    
  8.   
  9.   
  10. public static class ToolFactory   
  11. {   
  12.     /// <summary>   
  13.     /// 工厂制造工具   
  14.     /// </summary>   
  15.     /// <returns></returns>   
  16.     public static ITool CreateTool()   
  17.     {   
  18.         return new Hoe();  // 制造锄头   
  19.     }   
  20. }   
  21.   
  22.   
  23. public class EconomyPerson : Person   
  24. {   
  25.     /// <summary>   
  26.     /// 经济社会使用锄头耕作   
  27.     /// </summary>   
  28.     public override void Work()   
  29.     {   
  30.         //不用知道什么工具，只需知道工厂能买到工具，而不自己制造工具，但仅由工厂制造锄头   
  31.         ITool tool = ToolFactory.CreateTool();   
  32.         tool.UseTool();   
  33.         Console.WriteLine("经济社会使用工具耕作");   
  34.     }   
  35. }   

 

 

 

        从上面代码我可以看出：运用的经典的工厂模式， EconomyPerson仅仅对工厂耦合，并不关心工厂是怎样制造工具。

　　

　　场景三，现在社会：使用工具办公


C#代码
  1. public class Computer : ITool   
  2. {   
  3.     public void UseTool()   
  4.     {   
  5.         Console.WriteLine("使用电脑");   
  6.     }   
  7. }    
  8.   
  9.  public class ModernPerson : Person   
  10. {   
  11.     /// <summary>   
  12.     /// 从外部获取工具   
  13.     /// </summary>   
  14.     public ITool Tool { get; set; }   
  15.   
  16.     /// <summary>   
  17.     /// 现在人用不需要知道电脑是哪来的，直接拿来办公   
  18.     /// </summary>   
  19.     public override void Work()   
  20.     {   
  21.         //不知道使用什么工具和哪来的工具，只是机械化的办公   
  22.         Tool.UseTool();   
  23.         Console.WriteLine("使用工具办公");   
  24.     }   
  25. }  
XML/HTML代码
  1. <?xml version="1.0" encoding="utf-8" ?>  
  2. <configuration>  
  3.   
  4.   <configSections>  
  5.     <sectionGroup name="spring">  
  6.       <section name="context" type="Spring.Context.Support.ContextHandler, Spring.Core" />  
  7.       <section name="objects" type="Spring.Context.Support.DefaultSectionHandler, Spring.Core" />  
  8.     </sectionGroup>  
  9.   </configSections>  
  10.   
  11.   <spring>  
  12.   
  13.     <context>  
  14.       <resource uri="config://spring/objects" />  
  15.     </context>  
  16.   
  17.     <objects xmlns="http://www.springframework.net">  
  18.       <description>一个简单的控制反转例子</description>  
  19.   
  20.   
  21.       <object id="computer" type="SpringNetIoC.Computer, SpringNetIoC" />  
  22.   
  23.       <object id="modernPerson" type="SpringNetIoC.ModernPerson, SpringNetIoC">  
  24.         <property name="Tool" ref="computer"/>  
  25.       </object>  
  26.   
  27.   
  28.     </objects>  
  29.   
  30.   </spring>  
  31.   
  32. </configuration>  
 

 调用：

C#代码
  1. class Program   
  2. {   
  3.     static void Main(string[] args)   
  4.     {   
  5.         IApplicationContext ctx = ContextRegistry.GetContext();   
  6.         Person person = (Person)ctx.GetObject("modernPerson");   
  7.         person.Work();   
  8.         Console.ReadLine();   
  9.     }   
  10. }   

 

   

 

        从上面代码我们可以看出，把对象交给Spring.NET容器进行管理，ModernPerson类不需要知道具体使用什么工具，仅仅是机械化的工作。至于使用的什么工具，则由配置文件决定，所有对象由Spring.NET容器管理，这样可以实现动态的拆装组建和组件重用。依赖注入可以理解是反射工厂的加强版。这里主要是需要理解Spring.NET解耦合的思路。