大话spring. net之依赖注入

      谈到高级语言编程,我们就会联想到设计模式;谈到设计模式,我们就会说道怎么样解耦合。而Spring.NET的IoC容器其中的一种用途就是解耦合,其最经典的应用就是:依赖注入(Dependeny Injection)简称DI,目前DI是最优秀的解耦方式之一。下面我就来谈谈依赖注入的应用场景。

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

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


    /// <summary>
    
/// 抽象人类
    
/// </summary>

    public abstract class Person
    
{
        
/// <summary>
        
/// 使用工具劳动
        
/// </summary>

        public abstract void Work();
    }


    
public interface ITool
    
{
        
/// <summary>
        
/// 使用工具
        
/// </summary>

        void UseTool();
    }

 

  场景一,原始社会:原始人使用长矛打猎

复制代码
     public   class  Spear : ITool
    
{
        
public void UseTool()
        
{
            Console.WriteLine(
"使用长矛");
        }

    }
复制代码

    public class PrimitivePerson : Person
    
{
        
/// <summary>
        
/// 原始社会使用长矛打猎
        
/// </summary>

        public override void Work()
        
{
            
//知道打猎使用的是长矛,并且制造长矛
            ITool tool = new Spear();
            tool.UseTool();
            Console.WriteLine(
"使用长矛打猎");
        }

    }

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

  

  场景二,经济社会:使用工具耕作

复制代码
     public   class  Hoe : ITool
    
{
        
public void UseTool()
        
{
            Console.WriteLine(
"使用锄头");
        }

    }
复制代码

    public static class ToolFactory
    
{
        
/// <summary>
        
/// 工厂制造工具
        
/// </summary>
        
/// <returns></returns>

        public static ITool CreateTool()
        
{
            
return new Hoe();  // 制造锄头
        }

    }

 


    public class EconomyPerson : Person
    
{
        
/// <summary>
        
/// 经济社会使用锄头耕作
        
/// </summary>

        public override void Work()
        
{
            
//不用知道什么工具,只需知道工厂能买到工具,而不自己制造工具,但仅由工厂制造锄头
            ITool tool = ToolFactory.CreateTool();
            tool.UseTool();
            Console.WriteLine(
"经济社会使用工具耕作");
        }

    }

 

 

 

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

  

  场景三,现在社会:使用工具办公

复制代码
     public   class  Computer : ITool
    
{
        
public void UseTool()
        
{
            Console.WriteLine(
"使用电脑");
        }

    }
复制代码

 


    public class ModernPerson : Person
    
{
        
/// <summary>
        
/// 从外部获取工具
        
/// </summary>

        public ITool Tool getset; }

        
/// <summary>
        
/// 现在人用不需要知道电脑是哪来的,直接拿来办公
        
/// </summary>

        public override void Work()
        
{
            
//不知道使用什么工具和哪来的工具,只是机械化的办公
            Tool.UseTool();
            Console.WriteLine(
"使用工具办公");
        }

    }

 


<?xml version="1.0" encoding="utf-8" ?>
<configuration>

  
<configSections>
    
<sectionGroup name="spring">
      
<section name="context" type="Spring.Context.Support.ContextHandler, Spring.Core" />
      
<section name="objects" type="Spring.Context.Support.DefaultSectionHandler, Spring.Core" />
    
</sectionGroup>
  
</configSections>

  
<spring>

    
<context>
      
<resource uri="config://spring/objects" />
    
</context>

    
<objects xmlns="http://www.springframework.net">
      
<description>一个简单的控制反转例子</description>


      
<object id="computer" type="SpringNetIoC.Computer, SpringNetIoC" />

      
<object id="modernPerson" type="SpringNetIoC.ModernPerson, SpringNetIoC">
        
<property name="Tool" ref="computer"/>
      
</object>


    
</objects>

  
</spring>

</configuration>

 


    class Program
    
{
        
static void Main(string[] args)
        
{
            IApplicationContext ctx 
= ContextRegistry.GetContext();
            Person person 
= (Person)ctx.GetObject("modernPerson");
            person.Work();

            Console.ReadLine();
        }

    }

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

你可能感兴趣的:(spring,IOC,依赖注入)