依赖注入那些事儿（上）[转载]

设计模式 前端之家
前端之家收集整理的这篇文章主要介绍了依赖注入那些事儿（上）[转载]，前端之家小编觉得挺不错的，现在分享给大家，也给大家做个参考。

目录

写在前面的话

目录

1 IGame游戏公司的故事

1.1 讨论会

1.2 实习生小李的实现方法

1.3 架构师的建议

1.4 小李的小结

2 探究依赖注入

2.1 故事的启迪

2.2 正式定义依赖注入

3 依赖注入那些事儿

3.1 依赖注入的类别

3.1.1 Setter注入

3.1.2 Construtor注入

3.1.3 依赖获取

3.2 反射与依赖注入

3.3 多态的活性与依赖注入

3.3.1 多态性的活性

3.3.2 不同活性多态性依赖注入的选择

4 IoC Container

4.1 IoC Container出现的必然性

4.2 IoC Container的分类

4.2.1 重量级IoC Container

4.2.2 轻量级IoC Container

4.3 .NET平台上典型IoC Container推介

4.3.1 Spring.NET

4.3.2 Unity

参考文献

1 IGame游戏公司的故事

1.1 讨论会

话说有一个叫IGame的游戏公司，正在开发一款ARPG游戏（动作&角色扮演类游戏，如魔兽世界、梦幻西游这一类的游戏）。一般这类游戏都有一个基本的功能，就是打怪（玩家攻击怪物，借此获得经验、虚拟货币和虚拟装备），并且根据玩家角色所装备的武器不同，攻击效果也不同。这天，IGame公司的开发小组正在开会对打怪功能中的某一个功能点如何实现进行讨论，他们面前的大屏幕上是这样一份需求描述的ppt：

PHP?refimg=" + this.src)" style="border-right-width: 0px; display: block; float: none; border-top-width: 0px; border-bottom-width: 0px; margin-left: auto; border-left-width: 0px; margin-right: auto" border="0" alt="" width="504" height="379" src="http://img.jb51.cc/vcimg/static/loading.png" src="http://images.cnblogs.com/cnblogs_com/leoo2sk/WindowsLiveWriter/a5703ca6e7d5_D180/01_3.gif">

图1.1 需求描述ppt

各个开发人员，面对这份需求，展开了热烈的讨论，下面我们看看讨论会上都发生了什么。

1.2 实习生小李的实现方式

在经过一番讨论后，项目组长Peter觉得有必要整理一下各方的意见，他首先询问小李的看法。小李是某学校计算机系大三学生，对游戏开发特别感兴趣，目前是IGame公司的一名实习生。

经过短暂的思考，小李阐述了自己的意见：

“我认为，这个需求可以这么实现。HP当然是怪物的一个属性成员，而武器是角色的一个属性成员，类型可以使字符串，用于描述目前角色所装备的武器。角色类有一个攻击方法，以被攻击怪物为参数，当实施一次攻击时，攻击方法被调用，而这个方法首先判断当前角色装备了什么武器，然后据此对被攻击怪物的HP进行操作，以产生不同效果。”

而在阐述完后，小李也飞快的在自己的电脑上写了一个Demo，来演示他的想法，Demo代码如下。

Code：怪物

  1.    1: using System;
  1.    2: using System.Collections.Generic;
  1.    3: using System.Linq;
  1.    4: using System.Text;
  1.    5: 
  1.    6: namespace IGameLi
  1.    7: {
  1.    8:     /// <summary>
  1.    9:     /// 怪物
  1.   10:     /// </summary>
  1.   11:     internal sealed class Monster
  1.   12:     {
  1.   13:         /// <summary>
  1.   14:         /// 怪物的名字
  1.   15:         /// </summary>
  1.   16:         public String Name { get; set; }
  1.   17: 
  1.   18:         /// <summary>
  1.   19:         /// 怪物的生命值
  1.   20:         /// </summary>
  1.   21:         public Int32 HP { get; set; }
  1.   22: 
  1.   23:         public Monster(String name,Int32 hp)
  1.   24:         {
  1.   25:             this.Name = name;
  1.   26:             this.HP = hp;
  1.   27:         }
  1.   28:     }
  1.   29: }

Code：角色

  1.    1: using System;
  1.    2: using System.Collections.Generic;
  1.    3: using System.Linq;
  1.    4: using System.Text;
  1.    5: 
  1.    6: namespace IGameLi
  1.    7: {
  1.    8:     /// <summary>
  1.    9:     /// 角色
  1.   10:     /// </summary>
  1.   11:     internal sealed class Role
  1.   12:     {
  1.   13:         private Random _random = new Random();
  1.   14: 
  1.   15:         /// <summary>
  1.   16:         /// 表示角色目前所持武器的字符串
  1.   17:         /// </summary>
  1.   18:         public String WeaponTag { get; set; }
  1.   19: 
  1.   20:         /// <summary>
  1.   21:         /// 攻击怪物
  1.   22:         /// </summary>
  1.   23:         /// <param name="monster">被攻击的怪物</param>
  1.   24:         public void Attack(Monster monster)
  1.   25:         {
  1.   26:             if (monster.HP <= 0)
  1.   27:             {
  1.   28:                 Console.WriteLine("此怪物已死");
  1.   29:                 return;
  1.   30:             }
  1.   31: 
  1.   32:             if ("WoodSword" == this.WeaponTag)
  1.   33:             {
  1.   34:                 monster.HP -= 20;
  1.   35:                 if (monster.HP <= 0)
  1.   36:                 {
  1.   37:                     Console.WriteLine("攻击成功！怪物" + monster.Name + "已死亡");
  1.   38:                 }
  1.   39:                 else
  1.   40:                 {
  1.   41:                     Console.WriteLine("攻击成功！怪物" + monster.Name + "损失20HP");
  1.   42:                 }
  1.   43:             }
  1.   44:             else if ("IronSword" == this.WeaponTag)
  1.   45:             {
  1.   46:                 monster.HP -= 50;
  1.   47:                 if (monster.HP <= 0)
  1.   48:                 {
  1.   49:                     Console.WriteLine("攻击成功！怪物" + monster.Name + "已死亡");
  1.   50:                 }
  1.   51:                 else
  1.   52:                 {
  1.   53:                     Console.WriteLine("攻击成功！怪物" + monster.Name + "损失50HP");
  1.   54:                 }
  1.   55:             }
  1.   56:             else if ("MagicSword" == this.WeaponTag)
  1.   57:             {
  1.   58:                 Int32 loss = (_random.NextDouble() < 0.5) ? 100 : 200;
  1.   59:                 monster.HP -= loss;
  1.   60:                 if (200 == loss)
  1.   61:                 {
  1.   62:                     Console.WriteLine("出现暴击！！！");
  1.   63:                 }
  1.   64: 
  1.   65:                 if (monster.HP <= 0)
  1.   66:                 {
  1.   67:                     Console.WriteLine("攻击成功！怪物" + monster.Name + "已死亡");
  1.   68:                 }
  1.   69:                 else
  1.   70:                 {
  1.   71:                     Console.WriteLine("攻击成功！怪物" + monster.Name + "损失" + loss + "HP");
  1.   72:                 }
  1.   73:             }
  1.   74:             else
  1.   75:             {
  1.   76:                 Console.WriteLine("角色手里没有武器，无法攻击！");
  1.   77:             }
  1.   78:         }
  1.   79:     }
  1.   80: }

Code：测试代码

  1.    1: using System;
  1.    2: using System.Collections.Generic;
  1.    3: using System.Linq;
  1.    4: using System.Text;
  1.    5: 
  1.    6: namespace IGameLi
  1.    7: {
  1.    8:     class Program
  1.    9:     {
  1.   10:         static void Main(string[] args)
  1.   11:         {
  1.   12:             //生成怪物
  1.   13:             Monster monster1 = new Monster("小怪A",50);
  1.   14:             Monster monster2 = new Monster("小怪B",50);
  1.   15:             Monster monster3 = new Monster("关主",200);
  1.   16:             Monster monster4 = new Monster("最终Boss",1000);
  1.   17: 
  1.   18:             //生成角色
  1.   19:             Role role = new Role();
  1.   20: 
  1.   21:             //木剑攻击
  1.   22:             role.WeaponTag = "WoodSword";
  1.   23:             role.Attack(monster1);
  1.   24: 
  1.   25:             //铁剑攻击
  1.   26:             role.WeaponTag = "IronSword";
  1.   27:             role.Attack(monster2);
  1.   28:             role.Attack(monster3);
  1.   29: 
  1.   30:             //魔剑攻击
  1.   31:             role.WeaponTag = "MagicSword";
  1.   32:             role.Attack(monster3);
  1.   33:             role.Attack(monster4);
  1.   34:             role.Attack(monster4);
  1.   35:             role.Attack(monster4);
  1.   36:             role.Attack(monster4);
  1.   37:             role.Attack(monster4);
  1.   38: 
  1.   39:             Console.ReadLine();
  1.   40:         }
  1.   41:     }
  1.   42: }

程序运行结果如下：

PHP?refimg=" + this.src)" style="border-right-width: 0px; display: block; float: none; border-top-width: 0px; border-bottom-width: 0px; margin-left: auto; border-left-width: 0px; margin-right: auto" border="0" alt="" width="289" height="226" src="http://img.jb51.cc/vcimg/static/loading.png" src="http://images.cnblogs.com/cnblogs_com/leoo2sk/WindowsLiveWriter/a5703ca6e7d5_D180/02_3.gif">

图1.2 小李程序的运行结果

1.3 架构师的建议

小李阐述完自己的想法并演示了Demo后，项目组长Peter首先肯定了小李的思考能力、编程能力以及初步的面向对象分析与设计的思想，并承认小李的程序正确完成了需求中的功能。但同时，Peter也指出小李的设计存在一些问题，他请小于讲一下自己的看法。

小于是一名有五年软件架构经验的架构师，对软件架构、设计模式和面向对象思想有较深入的认识。他向Peter点了点头，发表了自己的看法：

“小李的思考能力是不错的，有着基本的面向对象分析设计能力，并且程序正确完成了所需要的功能。不过，这里我想从架构角度，简要说一下我认为这个设计中存在的问题。

首先，小李设计的Role类的Attack方法很长，并且方法中有一个冗长的if…else结构，且每个分支的代码的业务逻辑很相似，只是很少的地方不同。

再者，我认为这个设计比较大的一个问题是，违反了OCP原则。在这个设计中，如果以后我们增加一个新的武器，如倚天剑，每次攻击损失500HP，那么，我们就要打开Role，修改Attack方法。而我们的代码应该是对修改关闭的，当有新武器加入的时候，应该使用扩展完成，避免修改已有代码。

一般来说，当一个方法里面出现冗长的if…else或switch…case结构，且每个分支代码业务相似时，往往预示这里应该引入多态性来解决问题。而这里，如果把不同武器攻击看成一个策略，那么引入策略模式（Strategy Pattern）是明智的选择。

最后说一个小的问题，被攻击后，减HP、死亡判断等都是怪物的职责，这里放在Role中有些不当。”

Tip：OCP原则，即开放关闭原则，指设计应该对扩展开放，对修改关闭。

Tip：策略模式，英文名Strategy Pattern，指定义算法族，分别封装起来，让他们之间可以相互替换，此模式使得算法的变化独立于客户。

小于边说，边画了一幅UML类图，用于直观表示他的思想。

PHP?refimg=" + this.src)" style="border-right-width: 0px; display: block; float: none; border-top-width: 0px; border-bottom-width: 0px; margin-left: auto; border-left-width: 0px; margin-right: auto" border="0" alt="" width="586" height="407" src="http://img.jb51.cc/vcimg/static/loading.png" src="http://images.cnblogs.com/cnblogs_com/leoo2sk/WindowsLiveWriter/a5703ca6e7d5_D180/03_3.jpg">

图1.3 小于的设计

Peter让小李按照小于的设计重构Demo，小李看了看小于的设计图，很快完成。相关代码如下：

Code：IAttackStrategy接口

  1.    1: using System;
  1.    2: using System.Collections.Generic;
  1.    3: using System.Linq;
  1.    4: using System.Text;
  1.    5: 
  1.    6: namespace IGameLiAdv
  1.    7: {
  1.    8:     internal interface IAttackStrategy
  1.    9:     {
  1.   10:         void AttackTarget(Monster monster);
  1.   11:     }
  1.   12: }

Code：木剑

  1.    1: using System;
  1.    2: using System.Collections.Generic;
  1.    3: using System.Linq;
  1.    4: using System.Text;
  1.    5: 
  1.    6: namespace IGameLiAdv
  1.    7: {
  1.    8:     internal sealed class WoodSword : IAttackStrategy
  1.    9:     {
  1.   10:         public void AttackTarget(Monster monster)
  1.   11:         {
  1.   12:             monster.Notify(20);
  1.   13:         }
  1.   14:     }
  1.   15: }

Code：铁剑

  1.    1: using System;
  1.    2: using System.Collections.Generic;
  1.    3: using System.Linq;
  1.    4: using System.Text;
  1.    5: 
  1.    6: namespace IGameLiAdv
  1.    7: {
  1.    8:     internal sealed class IronSword : IAttackStrategy
  1.    9:     {
  1.   10:         public void AttackTarget(Monster monster)
  1.   11:         {
  1.   12:             monster.Notify(50);
  1.   13:         }
  1.   14:     }
  1.   15: }

Code：魔剑

  1.    1: using System;
  1.    2: using System.Collections.Generic;
  1.    3: using System.Linq;
  1.    4: using System.Text;
  1.    5: 
  1.    6: namespace IGameLiAdv
  1.    7: {
  1.    8:     internal sealed class MagicSword : IAttackStrategy
  1.    9:     {
  1.   10:         private Random _random = new Random();
  1.   11: 
  1.   12:         public void AttackTarget(Monster monster)
  1.   13:         {
  1.   14:             Int32 loss = (_random.NextDouble() < 0.5) ? 100 : 200;
  1.   15:             if (200 == loss)
  1.   16:             {
  1.   17:                 Console.WriteLine("出现暴击！！！");
  1.   18:             }
  1.   19:             monster.Notify(loss);
  1.   20:         }
  1.   21:     }
  1.   22: }

Code：怪物

  1.    1: using System;
  1.    2: using System.Collections.Generic;
  1.    3: using System.Linq;
  1.    4: using System.Text;
  1.    5: 
  1.    6: namespace IGameLiAdv
  1.    7: {
  1.    8:     /// <summary>
  1.    9:     /// 怪物
  1.   10:     /// </summary>
  1.   11:     internal sealed class Monster
  1.   12:     {
  1.   13:         /// <summary>
  1.   14:         /// 怪物的名字
  1.   15:         /// </summary>
  1.   16:         public String Name { get; set; }
  1.   17: 
  1.   18:         /// <summary>
  1.   19:         /// 怪物的生命值
  1.   20:         /// </summary>
  1.   21:         private Int32 HP { get; set; }
  1.   22: 
  1.   23:         public Monster(String name,Int32 hp)
  1.   24:         {
  1.   25:             this.Name = name;
  1.   26:             this.HP = hp;
  1.   27:         }
  1.   28: 
  1.   29:         /// <summary>
  1.   30:         /// 怪物被攻击时，被调用的方法，用来处理被攻击后的状态更改
  1.   31:         /// </summary>
  1.   32:         /// <param name="loss">此次攻击损失的HP</param>
  1.   33:         public void Notify(Int32 loss)
  1.   34:         {
  1.   35:             if (this.HP <= 0)
  1.   36:             {
  1.   37:                 Console.WriteLine("此怪物已死");
  1.   38:                 return;
  1.   39:             }
  1.   40: 
  1.   41:             this.HP -= loss;
  1.   42:             if (this.HP <= 0)
  1.   43:             {
  1.   44:                 Console.WriteLine("怪物" + this.Name + "被打死");
  1.   45:             }
  1.   46:             else
  1.   47:             {
  1.   48:                 Console.WriteLine("怪物" + this.Name + "损失" + loss + "HP");
  1.   49:             }
  1.   50:         }
  1.   51:     }
  1.   52: }

Code：角色

  1.    1: using System;
  1.    2: using System.Collections.Generic;
  1.    3: using System.Linq;
  1.    4: using System.Text;
  1.    5: 
  1.    6: namespace IGameLiAdv
  1.    7: {
  1.    8:     /// <summary>
  1.    9:     /// 角色
  1.   10:     /// </summary>
  1.   11:     internal sealed class Role
  1.   12:     {
  1.   13:         /// <summary>
  1.   14:         /// 表示角色目前所持武器
  1.   15:         /// </summary>
  1.   16:         public IAttackStrategy Weapon { get; set; }
  1.   17: 
  1.   18:         /// <summary>
  1.   19:         /// 攻击怪物
  1.   20:         /// </summary>
  1.   21:         /// <param name="monster">被攻击的怪物</param>
  1.   22:         public void Attack(Monster monster)
  1.   23:         {
  1.   24:             this.Weapon.AttackTarget(monster);
  1.   25:         }
  1.   26:     }
  1.   27: }

Code：测试代码

  1.    1: using System;
  1.    2: using System.Collections.Generic;
  1.    3: using System.Linq;
  1.    4: using System.Text;
  1.    5: 
  1.    6: namespace IGameLiAdv
  1.    7: {
  1.    8:     class Program
  1.    9:     {
  1.   10:         static void Main(string[] args)
  1.   11:         {
  1.   12:             //生成怪物
  1.   13:             Monster monster1 = new Monster("小怪A",1000);
  1.   17: 
  1.   18:             //生成角色
  1.   19:             Role role = new Role();
  1.   20: 
  1.   21:             //木剑攻击
  1.   22:             role.Weapon = new WoodSword();
  1.   23:             role.Attack(monster1);
  1.   24: 
  1.   25:             //铁剑攻击
  1.   26:             role.Weapon = new IronSword();
  1.   27:             role.Attack(monster2);
  1.   28:             role.Attack(monster3);
  1.   29: 
  1.   30:             //魔剑攻击
  1.   31:             role.Weapon = new MagicSword();
  1.   32:             role.Attack(monster3);
  1.   33:             role.Attack(monster4);
  1.   34:             role.Attack(monster4);
  1.   35:             role.Attack(monster4);
  1.   36:             role.Attack(monster4);
  1.   37:             role.Attack(monster4);
  1.   38: 
  1.   39:             Console.ReadLine();
  1.   40:         }
  1.   41:     }
  1.   42: }

编译运行以上代码，得到的运行结果与上一版本代码基本一致。

1.4 小李的小结

Peter显然对改进后的代码比较满意，他让小李对照两份设计和代码，进行一个小结。小李简略思考了一下，并结合小于对一次设计指出的不足，说道：

“我认为，改进后的代码有如下优点：

第一，虽然类的数量增加了，但是每个类中方法的代码都非常短，没有了以前Attack方法那种很长的方法，也没有了冗长的if…else，代码结构变得很清晰。

第二，类的职责更明确了。在第一个设计中，Role不但负责攻击，还负责给怪物减少HP和判断怪物是否已死。这明显不应该是Role的职责，改进后的代码将这两个职责移入Monster内，使得职责明确，提高了类的内聚性。

第三，引入Strategy模式后，不但消除了重复性代码，更重要的是，使得设计符合了OCP。如果以后要加一个新武器，只要新建一个类，实现IAttackStrategy接口，当角色需要装备这个新武器时，客户代码只要实例化一个新武器类，并赋给Role的Weapon成员就可以了，已有的Role和Monster代码都不用改动。这样就实现了对扩展开发，对修改关闭。”

Peter和小于听后都很满意，认为小李总结的非常出色。

IGame公司的讨论会还在进行着，内容是非常精彩，不过我们先听到这里，因为，接下来，我们要对其中某些问题进行一点探讨。别忘了，本文的主题可是依赖注入，这个主角还没登场呢！让主角等太久可不好。

2 探究依赖注入

2.1 故事的启迪

我们现在静下心来，再回味一下刚才的故事。因为，这个故事里面隐藏着依赖注入的出现原因。我说过不只一次，想真正认清一个事物，不能只看“它是什么？什么样子？”，而应该先弄清楚“它是怎么来的？是什么样的需求和背景促使了它的诞生？它被创造出来是做什么用的？”。

回想上面的故事。刚开始，主要需求是一个打怪的功能。小李做了一个初步面向对象的设计：抽取领域场景中的实体（怪物、角色等），封装成类，并为各个类赋予属性与方法，最后通过类的交互完成打怪功能，这应该算是面向对象设计的初级阶段。

在小李的设计基础上，架构师小于指出了几点不足，如不符合OCP，职责划分不明确等等，并根据情况引入策略模式。这是更高层次的面向对象设计。其实就核心来说，小于只做了一件事：利用多态性，隔离变化。它清楚认识到，这个打怪功能中，有些业务逻辑是不变的，如角色攻击怪物，怪物减少HP，减到0怪物就会死；而变化的仅仅是不同的角色持有不同武器时，每次攻击的效用不一样。于是他的架构，本质就是把变化的部分和不变的部分隔离开，使得变化部分发生变化时，不变部分不受影响。

我们再仔细看看小于的设计图，这样设计后，有个基本的问题需要解决：现在Role不依赖具体武器，而仅仅依赖一个IAttackStrategy接口，接口是不能实例化的，虽然Role的Weapon成员类型定义为IAttackStrategy，但最终还是会被赋予一个实现了IAttackStrategy接口的具体武器，并且随着程序进展，一个角色会装备不同的武器，从而产生不同的效用。赋予武器的职责，在Demo中是放在了测试代码里。

这里，测试代码实例化一个具体的武器，并赋给Role的Weapon成员的过程，就是依赖注入！这里要清楚，依赖注入其实是一个过程的称谓！

2.2 正式定义依赖注入

下面，用稍微正式一点的语言，定义依赖注入产生的背景缘由和依赖注入的含义。在读的过程中，读者可以结合上面的例子进行理解。

依赖注入产生的背景：

随着面向对象分析与设计的发展，一个良好的设计，核心原则之一就是将变化隔离，使得变化部分发生变化时，不变部分不受影响（这也是OCP的目的）。为了做到这一点，要利用面向对象中的多态性，使用多态性后，客户类不再直接依赖服务类，而是依赖于一个抽象的接口，这样，客户类就不能在内部直接实例化具体的服务类。但是，客户类在运作中又客观需要具体的服务类提供服务，因为接口是不能实例化去提供服务的。就产生了“客户类不准实例化具体服务类”和“客户类需要具体服务类”这样一对矛盾。为了解决这个矛盾，开发人员提出了一种模式：客户类（如上例中的Role）定义一个注入点（Public成员Weapon），用于服务类（实现IAttackStrategy的具体类，如WoodSword、IronSword和MagicSword，也包括以后加进来的所有实现IAttackStrategy的新类）的注入，而客户类的客户类（Program，即测试代码）负责根据情况，实例化服务类，注入到客户类中，从而解决了这个矛盾。

依赖注入的正式定义：

依赖注入（Dependency Injection），是这样一个过程：由于某客户类只依赖于服务类的一个接口，而不依赖于具体服务类，所以客户类只定义一个注入点。在程序运行过程中，客户类不直接实例化具体服务类实例，而是客户类的运行上下文环境或专门组件负责实例化服务类，然后将其注入到客户类中，保证客户类的正常运行。

3 依赖注入那些事儿

上面我们从需求背景的角度，讲述了依赖注入的来源和定义。但是，如果依赖注入仅仅就只有这么点东西，那也没有什么值得讨论的了。但是，上面讨论的仅仅是依赖注入的内涵，其外延还是非常广泛的，从依赖注入衍生出了很多相关的概念与技术，下面我们讨论一下依赖注入的“那些事儿”。

3.1 依赖注入的类别

依赖注入有很多种方法，上面看到的例子中，只是其中的一种，下面分别讨论不同的依赖注入类型。

3.1.1 Setter注入

第一种依赖注入的方式，就是Setter注入，上面的例子中，将武器注入Role就是Setter注入。正式点说：

Setter注入（Setter Injection）是指在客户类中，设置一个服务类接口类型的数据成员，并设置一个Set方法作为注入点，这个Set方法接受一个具体的服务类实例为参数，并将它赋给服务类接口类型的数据成员。

PHP?refimg=" + this.src)" style="border-right-width: 0px; display: block; float: none; border-top-width: 0px; border-bottom-width: 0px; margin-left: auto; border-left-width: 0px; margin-right: auto" border="0" alt="" width="566" height="352" src="http://img.jb51.cc/vcimg/static/loading.png" src="http://images.cnblogs.com/cnblogs_com/leoo2sk/WindowsLiveWriter/a5703ca6e7d5_D180/04_6.jpg">

图3.1 Setter注入示意

上图展示了Setter注入的结构示意图，客户类ClientClass设置IServiceClass类型成员_serviceImpl，并设置Set_ServiceImpl方法作为注入点。Context会负责实例化一个具体的ServiceClass，然后注入到ClientClass里。

下面给出Setter注入的示例代码。

Code：IServiceClass 
  1.    1: using System;
  1.    2: using System.Collections.Generic;
  1.    3: using System.Linq;
  1.    4: using System.Text;
  1.    5: 
  1.    6: namespace SetterInjection
  1.    7: {
  1.    8:     internal interface IServiceClass
  1.    9:     {
  1.   10:         String ServiceInfo();
  1.   11:     }
  1.   12: }
Code：ServiceClassA 
  1.    1: using System;
  1.    2: using System.Collections.Generic;
  1.    3: using System.Linq;
  1.    4: using System.Text;
  1.    5: 
  1.    6: namespace SetterInjection
  1.    7: {
  1.    8:     internal class ServiceClassA : IServiceClass
  1.    9:     {
  1.   10:         public String ServiceInfo()
  1.   11:         {
  1.   12:             return "我是ServceClassA";
  1.   13:         }
  1.   14:     }
  1.   15: }
Code：ServiceClassB 
  1.    1: using System;
  1.    2: using System.Collections.Generic;
  1.    3: using System.Linq;
  1.    4: using System.Text;
  1.    5: 
  1.    6: namespace SetterInjection
  1.    7: {
  1.    8:     internal class ServiceClassB : IServiceClass
  1.    9:     {
  1.   10:         public String ServiceInfo()
  1.   11:         {
  1.   12:             return "我是ServceClassB";
  1.   13:         }
  1.   14:     }
  1.   15: }
Code：ClientClass 
  1.    1: using System;
  1.    2: using System.Collections.Generic;
  1.    3: using System.Linq;
  1.    4: using System.Text;
  1.    5: 
  1.    6: namespace SetterInjection
  1.    7: {
  1.    8:     internal class ClientClass
  1.    9:     {
  1.   10:         private IServiceClass _serviceImpl;
  1.   11: 
  1.   12:         public void Set_ServiceImpl(IServiceClass serviceImpl)
  1.   13:         {
  1.   14:             this._serviceImpl = serviceImpl;
  1.   15:         }
  1.   16: 
  1.   17:         public void ShowInfo()
  1.   18:         {
  1.   19:             Console.WriteLine(_serviceImpl.ServiceInfo());
  1.   20:         }
  1.   21:     }
  1.   22: }

原文地址：http://www.cnblogs.com/leoo2sk/archive/2009/06/17/1504693.html

猜你在找的设计模式相关文章

适配器模式-让不兼容的接口得以适配
适配器模式将一个类的接口转换成客户期望的另一个接口，使得原本接口不兼容的类可以相互合...
策略模式-定义一个算法族
策略模式定义了一系列算法族，并封装在类中，它们之间可以互相替换，此模式让算法的变化独...
设计模式之高质量代码
设计模式讲的是如何编写可扩展、可维护、可读的高质量代码，它是针对软件开发中经常遇到的...
模板方法模式-封装一套算法流程
模板方法模式在一个方法中定义一个算法的骨架，而将一些步骤延迟到子类中，使得子类可以在...
迭代器模式-统一集合的遍历方式
迭代器模式提供了一种方法，用于遍历集合对象中的元素，而又不暴露其内部的细节。
单例模式的五种实现方式及优缺点
单例模式（Singleton Design Pattern）保证一个类只能有一个实例，并提供一个全局访问点。
组合模式-统一的处理个别对象与组合对象
组合模式可以将对象组合成树形结构来表示“整体-部分”的层次结构，使得客户可以用一致的方...
装饰者模式-动态的包装原有对象的行为
装饰者模式能够更灵活的，动态的给对象添加其它功能，而不需要修改任何现有的底层代码。
观察者模式-将消息通知给观察者
观察者模式（Observer Design Pattern）定义了对象之间的一对多依赖，当对象状态改变的时候...
代理模式-访问对象的代理而非其本身
代理模式为对象提供一个代理，来控制对该对象的访问。代理模式在不改变原始类代码的情况下...
算法设计模式多媒体技术正则表达式ElasticsearchFlinkHadoopIDE
受约束摘*day25Java常用类库置信lamda留存持续录入年后正则表达式303.17regularexpre匹多模适20130322基础理论pathmunge涵义reectok需要转义的特资源分享validationex简明魔法里弄形如源码实现完备actionscript