本篇幅主要介绍控制反转的一些概念，和如何使用Unity实现Ioc。在介绍的时候，会尽量结合代码来讲解一些概念。
1.什么是DI?
DI即控制反转，是将对具体实现类的依赖转变为对接口的依赖，这样在编程中，就可以发挥类的多态性。我们先假设一台印钞机，功能是打印钞票，根据使用的模板，可以印人民币(想到这里，我做梦都乐了)。具体实现如下代码：
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks; namespace IocWithUnity
{
/// <summary>
/// 印钞机
/// </summary>
public class CashMachine
{
public CashMachine() { } public void Print()
{
CNYCashTemplate template = new CNYCashTemplate(); string templateContent = template.GetTemplate(); System.Console.WriteLine(templateContent);
}
}
/// <summary>
/// 人民币钞票模板
/// </summary>
public class CNYCashTemplate
{
public CNYCashTemplate() { } public string GetTemplate()
{
return "这是人民币模板";
}
}
}
是不是很爽？可以印很多RMB了。哈哈哈哈！！！可是有一天，我们的机器要卖去美国，印美钞，怎么办，于是，我们加了一个美钞模板。代码如下：
/// <summary>
/// 美钞钞票模板
/// </summary>
public class USDCashTemplate
{
public USDCashTemplate() { } public string GetTemplate()
{
return "This is US Dollor.";
}
}
这下尴尬了，我们还得再建一个USDCashMachine。同样的代码，再写一遍。单是优秀的程序猿具有一个良好的特质--懒，所以我们打算改一下，成下面那样:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks; namespace IocWithUnity
{
/// <summary>
/// 印钞机
/// </summary>
public class CashMachine
{
public CashMachine() { } public void Print(ICashTemplate template)
{
string templateContent = template.GetTemplate(); System.Console.WriteLine(templateContent);
}
}
/// <summary>
/// 印钞模块
/// </summary>
public interface ICashTemplate
{
/// <summary>
/// 获取钞票模板
/// </summary>
/// <returns></returns>
string GetTemplate();
} /// <summary>
/// 人民币钞票模板
/// </summary>
public class CNYCashTemplate : ICashTemplate
{
public CNYCashTemplate() { } public string GetTemplate()
{
return "这是人民币模板";
}
}
/// <summary>
/// 美钞钞票模板
/// </summary>
public class USDCashTemplate : ICashTemplate
{
public USDCashTemplate() { } public string GetTemplate()
{
return "This is US Dollor.";
}
}
}
我们在调用的时候就变成了
ICashTemplate template = new USDCashTemplate();
new CashMachine().Print(template);
这个时候，我们想印美钞，就放美钞的模板，想印人民币，就印人民币的模板，厉害了吧？
没错，这就是面向接口的依赖反转，我们的CashMachine从依赖CNYCashTemplate这个具体实现，变成了对ICashTemplate接口的依赖，在上面我们采用的是方法的注入，我们也可以用构造函数注入，用属性注入，思路都是一样的。这就是为什么我们一直强调
面向接口编程，因为面向接口编程可以增强代码结构的稳定性和可扩展性。
2.什么是Ioc?
上面我们的印钞机已经可以印各种钞票了。那么我们在实际开发当中，如果你进行了分层，想必应该是这样的：
Cash.Business---业务层
Cash.Templates---钞票模板实现
Cash.IContract--接口层
那么这三层的依赖关系应该是
作为一个有代码洁癖的猿，肯定是不想有那么多复杂的关系的。业界有一句著名的话怎么说来着，没有加一层解决不了的事情，如果有，那么就加俩层。
变成这样之后，是不是感觉简洁很多了，没有错Infrustructure框架层做的事情就是这个，我们将创建具体对象的工作交给了框架，从此以后，CashBusiness的依赖关系就稳定了，我们也过上了衣食无忧，逍遥快乐的日子。
3.Unity的基本使用
上面Infrustructure的功能，我们使用的就是Unity。
public static class IocContainer
{
private static IUnityContainer _container = null;
static IocContainer()
{
_container = new UnityContainer();
}
/// <summary>
/// 注册一个实例作为T的类型
/// </summary>
/// <typeparam name="T">需要注册的类型</typeparam>
/// <param name="instance">需要注册的实例</param>
public static void Register<T>(T instance)
{
_container.RegisterInstance<T>(instance);
}
/// <summary>
/// 注册一个名为name的T类型的实例
/// </summary>
/// <typeparam name="T">需要注册的类型</typeparam>
/// <param name="name">关键字名称</param>
/// <param name="instance">实例</param>
public static void Register<T>(string name, T instance)
{
_container.RegisterInstance(name, instance);
}
/// <summary>
/// 将类型TFrom注册为类型TTo
/// </summary>
/// <typeparam name="TFrom"></typeparam>
/// <typeparam name="TTo"></typeparam>
public static void Register<TFrom, TTo>() where TTo : TFrom
{
_container.RegisterType<TFrom, TTo>();
}
/// <summary>
/// 将类型TFrom注册为类型TTo
/// </summary>
/// <typeparam name="TFrom"></typeparam>
/// <typeparam name="TTo"></typeparam>
/// <typeparam name="lifetime"></typeparam>
public static void Register<TFrom, TTo>(LifetimeManager lifetime) where TTo : TFrom
{
_container.RegisterType<TFrom, TTo>(lifetime);
}
/// <summary>
/// 将类型TFrom注册名为name类型TTo
/// </summary>
/// <typeparam name="TFrom"></typeparam>
/// <typeparam name="TTo"></typeparam>
public static void Register<TFrom, TTo>(string name) where TTo : TFrom
{
_container.RegisterType<TFrom, TTo>(name);
}
/// <summary>
/// 通过关键字name来获取一个实例对象
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="name"></param>
/// <returns></returns>
public static T Resolve<T>(string name)
{
return _container.Resolve<T>(name);
}
/// <summary>
/// 获取一个为T类型的对象
/// </summary>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
public static T Resolve<T>()
{
return _container.Resolve<T>();
}
/// <summary>
/// 获取所有注册类型为T的对象实例
/// </summary>
/// <typeparam name="T">需要获取的类型的对象</typeparam>
/// <returns></returns>
public static IEnumerable<T> ResolveAll<T>()
{
return _container.ResolveAll<T>();
}
}
上面代码中Register就是将对象或实现类，注册到Ioc容器中，在需要使用的地方再调用Resolve获取对象即可，这样，无论我们在哪里需要，都可以用Ioc容器来获取对象，而不再需要使用new来创建对象了。
4.使用配置文件配置注入
但是，我们显然不满足于这样，我们还想把实现，彻彻底底的从代码中移除，这里我们就可以借助配置文件来实现了。首先，我们在IocContainer里添加一个静态构造函数，让程序在初次使用IocContainer时加载配置，
static IocContainer()
{
_container = new UnityContainer(); object unitySection = ConfigurationManager.GetSection("unity");
if (unitySection == null) return; UnityConfigurationSection section = (UnityConfigurationSection)unitySection;
section.Configure(_container, "Default");
}
/// <summary>
/// 从文件中加载Unity注入的对象和映射关系等
/// </summary>
/// <param name="configFile">Unity容器配置文件的路径</param>
public static void LoadUnityConfig(string configFile)
{
string filePath = configFile;
var fileMap = new ExeConfigurationFileMap { ExeConfigFilename = filePath }; Configuration configuration = ConfigurationManager.OpenMappedExeConfiguration(fileMap, ConfigurationUserLevel.None);
UnityConfigurationSection unitySection = (UnityConfigurationSection)configuration.GetSection("unity");
foreach (var item in unitySection.Containers)
{
_container.LoadConfiguration(unitySection, item.Name);
}
}
web.config(WEB项目是在web.config)里配置我们配置文件的路径，在configuration节点中添加如下配置
<configSections>
<section name="unity" type="Microsoft.Practices.Unity.Configuration.UnityConfigurationSection, Microsoft.Practices.Unity.Configuration"/>
</configSections>
<unity configSource="unity.config"/>
接下来我们来配置我们的unity.config文件（这里unity.config是放在运行目录下的，WEB网站下应该是与bin目录同级）
<?xml version="1.0" encoding="utf-8" ?>
<unity xmlns= "http://schemas.microsoft.com/practices/2010/unity ">
<sectionExtension type="Microsoft.Practices.Unity.InterceptionExtension.Configuration.InterceptionConfigurationExtension, Microsoft.Practices.Unity.Interception.Configuration"/>
<!--注入对象-->
<typeAliases>
<!--表示单例-->
<typeAlias alias="singleton" type="Microsoft.Practices.Unity.ContainerControlledLifetimeManager,Microsoft.Practices.Unity" />
<!--表示每次使用都进行创建-->
<typeAlias alias="transient" type="Microsoft.Practices.Unity.TransientLifetimeManager,Microsoft.Practices.Unity" />
</typeAliases>
<container name= "Default">
<!--配置sql-->
<!--<register type= "接口类,接口dll" mapTo= "实现类,实现dll" name="实例名">-->
<register type= "MJD.Framework.Sql.Interfaces.IConnectionFactory,MJD.Framework.Sql" mapTo= "MJD.Framework.Sql.Oracle.ConnectionFactory,MJD.Framework.Sql.Oracle">
<lifetime type="singleton" />
</register>
</container>
</unity>
这样，我们就可以将实现彻底的解耦出来了。怎么样，是不是很酷？以后再也不需要再去更改代码了，直接配置就可以了。
5.三种生命周期
在上面的配置中，眼尖的你可能会发现，在register下还配置了一个lifetime，type填写的是一个别名。这里就是所谓的生命周期，在Unity中有三种生命周期
ContainerControlledLifetimeManager，即单例，生命周期与容器的生命周期一样，一般如果我们使用静态的容器，那么这个就等同于我们的单例模式；
TransientLifetimeManager，临时的，即每次创建容器都会new一个对象给我们使用； HierarchicalLifetimeManager，这个用得比较少，假如容器有分层，有子容器，那么父容器与子容器中的对象都是单例的，但是子类与父类里的对象不是同一个；