[.net 面向对象程序设计深入](26)实战设计模式——使用Ioc模式(控制反转或依赖注入)实现松散耦合设计(1)

时间:2024-01-21 15:44:33

[.net 面向对象程序设计深入](31)实战设计模式——使用IoC模式(控制反转或依赖注入)实现松散耦合设计(1)

1,关于IOC模式

先看一些名词含义:

IOC: Inversion of control 控制反转,简称

DI: Dependency Injection 依赖注入,简称

DIP: 依赖倒置原则 一种软件架构设计的原则(抽象概念),“设计模式使用场景及原则”一篇中介绍过设计模式的几种原则之一。

IoC容器:依赖注入的框架,用来映射依赖,管理对象创建和生存周期(DI框架)。

(1)IOC和DI,是站在不同角度的描述,本身是同一个概念

先说说这两个对于初次接触到的同学难以理解的概念,首先这两个东东是一回事,只是因为角度不同,有了两个名字。

举个不太恰当的例子,比如一个人,爸爸叫你儿子,爷爷叫你孙子,那这个儿子和孙子都是你,是同一个人,只是站的角度不同,这么说容易理解了吧。

依赖注入(DI)是从应用程序的角度在描述,可以把依赖注入描述完整点:应用程序依赖容器创建并注入它所需要的外部资源;

而控制反转(IOC)是从容器的角度在描述,描述完整点:容器控制应用程序,由容器反向的向应用程序注入应用程序所需要的外部资源。

(2)是一种大粒度的设计模式

和GOF的23种设计模式相比较。IOC模式(通常中文称"依赖注入"或“依赖倒置”),由于出现时间比较晚,没有被收录。

其次和23种设计模式相比较,它的粒度更大一些,和MVC模式一样,通常到架构层面了,而不是具体代码片段级别。理解到这里就可以了。

但它仍然是设计模式,只是和23种设计模式比,23种模式是战术层面,IOC模式是战略层面的。

依赖注入映射到面向对象程序开发中就是:高层类应该依赖底层基础设施来提供必要的服务。

编写松耦合的代码说起来很简单,但是实际上写着写着就变成了紧耦合。

一个比较难理解的正式定义如下:

依赖注入(Dependency Injection),是这样一个过程:由于某客户类只依赖于服务类的一个接口,而不依赖于具体服务类,所以客户类只定义一个注入点。

在程序运行过程中,客户类不直接实例化具体服务类实例,而是客户类的运行上下文环境或专门组件负责实例化服务类,然后将其注入到客户类中,保证客户类的正常运行。

下面的说明比较容易理解:

理解DI的关键是:“谁依赖谁,为什么需要依赖,谁注入谁,注入了什么”,那我们来深入分析一下:

  ●谁依赖于谁:当然是应用程序依赖于IoC容器;

  ●为什么需要依赖:应用程序需要IoC容器来提供对象需要的外部资源;

  ●谁注入谁:很明显是IoC容器注入应用程序某个对象,应用程序依赖的对象;

  ●注入了什么:就是注入某个对象所需要的外部资源(包括对象、资源、常量数据)。

  IoC和DI由什么关系呢?其实它们是同一个概念的不同角度描述,由于控制反转概念比较含糊(可能只是理解为容器控制对象这一个层面,很难让人想到谁来维护对象关系),

所以2004年大师级人物Martin Fowler又给出了一个新的名字:“依赖注入”,相对IoC 而言,“依赖注入”明确描述了“被注入对象依赖IoC容器配置依赖对象”。

2,依赖注入的作用

依赖注入不是目的,它是一系列工具和手段。

最终的目的是帮助我们开发出松散耦合(loose coupled)、可维护、可测试的代码和程序。

这条原则的做法是大家熟知的面向接口,或者说是面向抽象编程。

常见的三层架构中,虽然表面上表现、业务、数据分层设计。但在数据库层往往会产生一些与具体业务有关的类,而且如果不严格遵循代码规范,会导致产生表现层直接new数据层的情况。

如果要换个数据源呢?假如不使用ADO.NET等试,改为Http呢?这将是领域逻辑层和表现层与之耦合的代码要进行大量更动。

这样使得整个系统紧耦合,并且可测试性差。

在系统设计过程中,各个类从上层到下层类之间必然会产生耦合,如果完全没有耦合,那么这个类或程序集就可以从项目中移除了。

因此如何使之达到松散耦合,从而提高可测试性呢?依赖注入将能很好的解决上述问题。

3,IOC模式应用示例

下面以一个简单购物过程为例来说明IOC模式如何实现松散耦合。

(1)传统三层模式

[.net 面向对象程序设计深入](26)实战设计模式——使用Ioc模式(控制反转或依赖注入)实现松散耦合设计(1)

代码如下:

    public class DalSqlServer
{
public void Add()
{
Console.WriteLine("在数据库中添加一条订单!");
}
}
    public class Order
{
private readonly DalSqlServer dal = new DalSqlServer();//添加一个私有变量保存数据库操作的对象
public void Add()
{
dal.Add();
}
}
    class Program
{
static void Main(string[] args)
{
Order order = new Order();
order.Add();
Console.Read(); }
}

运行结果:

[.net 面向对象程序设计深入](26)实战设计模式——使用Ioc模式(控制反转或依赖注入)实现松散耦合设计(1)

上面的代码看着功能都实现了,然而突然老板说,SqlServer要花钱买,我们使用免费的Access吧,好吧,那就改改喽。改动后如下:

这时,我们只能再增加一个DalAcess类,来解决,代码如下:

public class DalAccess
{
public void Add()
{
Console.WriteLine("在Access数据库中添加一条订单!");
}
}
   public class Order
{
private readonly DalAccess dal = new DalAccess();//添加一个私有变量保存Access数据库操作的对象
public void Add()
{
dal.Add();
}
}
    class Program
{
static void Main(string[] args)
{
Order order = new Order();
order.Add();
Console.Read(); }
}

运行结果:

[.net 面向对象程序设计深入](26)实战设计模式——使用Ioc模式(控制反转或依赖注入)实现松散耦合设计(1)

正在这时,老板来了,说最近生意好,订单剧增,改成MySql数据库吧,蒙蔽了吧,示例代码中只有一个Add()的方法,可实际项目中,不知道有多少工作量了。

(2)使用IOC模式改进

只所以在需求变化时,我们的代码改动量如此之大,是因为耦合,耦合,耦合。

前面说了耦合不可能不存在,如果不存在,那这个代码就可以从项目中移除了,但是要让让代码可维护性强,就必须使用模式化的开发

当然依赖注入就能解决上述问题,依赖注入(DI),它提供一种机制,将需要依赖(低层模块)对象的引用传递给被依赖(高层模块)对象

我们示例中低层模块就是DalSqlServer,DalAccsess,DalMySql等,高层模块就是Order.

那么如何在Order内部不依赖DalSqlServer,DalAccsess,DalMySql的情况下传递呢,

这就需要对DalSqlServer,DalAccsess,DalMySql进行抽象设计,我们设计一个IData数据接口对象,让DalSqlServer,DalAccsess,DalMySql去具体实现它,

在传递过程中,我们只需要订单处理Order和数据接口层IData耦合,这样,即使数据库再变化,但IData是稳定的。也不需要再改动Order中的代码了。是不是很不错的解耦呢?

改进后如下:

[.net 面向对象程序设计深入](26)实战设计模式——使用Ioc模式(控制反转或依赖注入)实现松散耦合设计(1)

代码如下:

   public class DalOracle : IData
{
public void Add()
{
Console.WriteLine("在Oracle数据库中添加一条订单!");
}
}
    public class DalAccess : IData
{
public void Add()
{
Console.WriteLine("在Access数据库中添加一条订单!");
}
}
    public class DalMySql : IData
{
public void Add()
{
Console.WriteLine("在MySql数据库中添加一条订单!");
}
}
    public class DalSqlServer : IData
{
public void Add()
{
Console.WriteLine("在SqlServer数据库中添加一条订单!");
}
}

定单处理类:

  public class Order
{
private IData idata; //定义私有变量保存抽象出来的数据接口 /// <summary>
/// 通过构造函数注入
/// </summary>
/// <param name="iData"></param>
public Order(IData iData)
{
this.idata = iData; //传递依赖
} public void Add()
{
idata.Add();
}
}

展示:

    class Program
{
static void Main(string[] args)
{
//定义空订单
Order order=null; //使用SqlServer
order = new Order(new DalSqlServer());
order.Add(); //使用Oracle
order = new Order(new DalOracle());
order.Add(); //使用Accesss
order = new Order(new DalAccess());
order.Add(); //使用MySql
order = new Order(new DalMySql());
order.Add(); Console.Read();
}
}

这样就可以随意切换数据库了,运行结果如下:

[.net 面向对象程序设计深入](26)实战设计模式——使用Ioc模式(控制反转或依赖注入)实现松散耦合设计(1)

(3)更进一步改进,控制反转

上面说到站在另一个角度讲,我们把选择数据库的权限交给第三方,是不是可以不用每次在创建订单时都指定依赖对象(即具体数据类),也就是控制反转。

针对上面的每次指定依赖对象的问题,处理的方式很多,最简单的我们可以通过一个配置文件来指定所使用的具体数据库,在传递时通过反射的方式来映射数据类。

这样就就灵活多了。

4,IOC注入的几种方式

 (1)构造函数注入

上面示例就是这种方式

(2)属性注入

    public class Order
{
public IData Idata{get;set;} public void Add()
{
this.Idata.Add();
}
}
class Program
{
static void Main(string[] args)
{
//定义空订单
Order order=null; //使用SqlServer
order = new Order();
order.Idata = new DalSqlServer();
order.Add(); //使用Oracle
order = new Order();
order.Idata = new DalOracle();
order.Add(); //使用Accesss
order = new Order();
order.Idata = new DalAccess();
order.Add(); //使用MySql
order = new Order();
order.Idata = new DalMySql();
order.Add(); Console.Read();
}
}

(3)方法注入

 public class Order
{
private IData idata; //私有变量保存抽象接口 //通过Idata方法传递依赖
public void Idata(IData idata)
{
this.idata = idata;
}
public void Add()
{
this.idata.Add();
}
}
   class Program
{
static void Main(string[] args)
{
//定义空订单
Order order=null; //使用SqlServer
order = new Order();
order.Idata( new DalSqlServer());
order.Add(); //使用Oracle
order = new Order();
order.Idata(new DalOracle());
order.Add(); //使用Accesss
order = new Order();
order.Idata(new DalAccess());
order.Add(); //使用MySql
order = new Order();
order.Idata(new DalMySql());
order.Add(); Console.Read();
}
}

5,IOC容器(或DI框架)

对于大型项目来说,相互依赖的组件比较多。如果还用手动的方式,自己来创建和注入依赖的话,显然效率很低,而且往往还会出现不可控的场面。正因如此,IoC容器诞生了。IoC容器实际上是一个DI框架,它能简化我们的工作量。它包含以下几个功能:

动态创建、注入依赖对象。
管理对象生命周期。
映射依赖关系。

比如比较知名的“基于DDD的现代ASP.NET开发框架--ABP”使用Castle Windsor框架处理依赖注入。它是最成熟的DI框架之一。还有很多其他的框架,如Unity,Ninject,StructureMap,Autofac等等。

下面是园友整理出来的一些常用的IOC容器及官网:

(1). Ninject: http://www.ninject.org/

(2). Castle Windsor: http://www.castleproject.org/container/index.html

(3). Autofac: http://code.google.com/p/autofac/

(4). StructureMap: http://docs.structuremap.net/

(5). Unity: http://unity.codeplex.com/

(6). MEF: http://msdn.microsoft.com/zh-cn/library/dd460648.aspx

(7). Spring.NET: http://www.springframework.net/

(8). LightInject: http://www.lightinject.net/ (推荐使用Chrome浏览器访问)

6,总结

(1)依赖注入,是一种结构型的设计模式,即IOC模式。

(2)IOC意思为控制反转和依赖注入是同一概念的不同角度的说法。

(3)依赖注入是让我们的应用程序依赖于抽象出来的服务类的接口,而不是具体的服务类,从而在具体的服务类发生需求变化时,我们注入新的服务接口,做到松散耦合。

(4)依赖注入有三种简单的方式,即构造函数注入,属性注入,方法注入。

(5)在大型项目中为了解决手动创建注入的效率低下,诞生了IOC容器,常见的有:Unity、Ninject、StructureMap、Autofac、Spring.NET等。

7,源代码

https://github.com/yubinfeng/BlogExamples.git

==============================================================================================

返回目录

<如果对你有帮助,记得点一下推荐哦,如有有不明白或错误之处,请多交流>

<对本系列文章阅读有困难的朋友,请先看 《.net 面向对象编程基础》和 《.net 面向对象程序设计进阶》 >

<转载声明:技术需要共享精神,欢迎转载本博客中的文章,但请注明版权及URL>

.NET 技术交流群:467189533 [.net 面向对象程序设计深入](26)实战设计模式——使用Ioc模式(控制反转或依赖注入)实现松散耦合设计(1)

==============================================================================================