本篇幅主要介绍控制反转的一些概念，和如何使用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，这个用得比较少，假如容器有分层，有子容器，那么父容器与子容器中的对象都是单例的，但是子类与父类里的对象不是同一个；