一、什么是Ioc
IoC（Inverse of Control）的字面意思是控制反转，它包括两个内容： 控制、反转
可以假设这样一个场景：火车运货，不同类型的车厢运送不同类型的货物，板车运送圆木，罐车运送柴油，箱车运送水果。那么对于运送货物这件事，需是列车挂不同的车厢运送货物。显然列车和运送货物之间是有依赖关系的（控制：依赖关系）。我们把列车挂什么样的车厢交给调度中心，而不是交给列车决定，这就形成了依赖反转。
因为IoC确实不够开门见山，因此业界曾进行了广泛的讨论，最终软件界的泰斗级人物Martin Fowler提出了DI（依赖注入：Dependency Injection）的概念用以代替IoC，即让调用类对某一接口实现类的依赖关系由第三方（容器或协作类）注入，以移除调用类对某一接口实现类的依赖。“依赖注入”这个名词显然比“控制反转”直接明了、易于理解。
依赖注入和控制反转是同一概念吗？
根据上面的讲述，应该能看出来，依赖注入和控制反转是对同一件事情的不同描述，从某个方面讲，就是它们描述的角度不同。依赖注入是从应用程序的角度在描述，可以把依赖注入描述完整点：应用程序依赖容器创建并注入它所需要的外部资源；而控制反转是从容器的角度在描述，描述完整点：容器控制应用程序，由容器反向的向应用程序注入应用程序所需要的外部资源。
其实IoC/DI对编程带来的最大改变不是从代码上，而是从思想上，发生了“主从换位”的变化。应用程序原本是老大，要获取什么资源都是主动出击，但是在IoC/DI思想中，应用程序就变成被动的了，被动的等待IoC/DI容器来创建并注入它所需要的资源了。
这么小小的一个改变其实是编程思想的一个大进步，这样就有效的分离了对象和它所需要的外部资源，使得它们松散耦合，有利于功能复用，更重要的是使得程序的整个体系结构变得非常灵活。
举个例子：有一个闹钟会问早安，当它地理位置定位在中国的时候，它会问候：早安；当在美国的时候，它会问候：Good Morning；那么我们把闹钟看做一个客户，问候看做一个服务，这个闹钟是依赖于服务的。闹钟遵从OCP原则应该有一个SayMorning的注入点，而问候就需要使用策略模式列出。实现这个功能：
public interface ISayMorning
{ void SayMorning();
} public class ChinesePosition:ISayMorning
{
void SayMorning()
{
Console.Writeline("早安！");
}
} public class EnglishPosition:ISayMorning
{
void SayMorning()
{
Console.Writeline("GoodMorning!");
}
} //下面创建客户 public class ClockClient()
{
public ISayMorning SayService{set;}
public Set_Sayservices(ISayMorning sayService)
{
SayService=sayService;
} public SayMorning()
{
SayService.SayMorning();
}
} //主函数中 var clock=new ClockClient();
var saysChinese=new ChinesePosition();
clock.Set_Sayservices(saysChinese);
clock.SayMorning();
以上，闹钟说话依赖于说话服务，说话服务有很多策略（算法），我们将服务注入（DL）客户，将客户的依赖项（服务）反转到对象创建后再根据类别注入选择，这就形成了依赖反转（IOC）。这样做的的好处是策略变化（地区），我们只要新建类就好了
而不用修改已经写好的代码，实现了OCP（设计模式遵循的六大原则之 开闭原则）。
二、几个相似相关的概念
依赖倒置原则（DIP）：一种软件架构设计的原则（抽象概念）。
控制反转（IoC）：一种反转流、依赖和接口的方式（DIP的具体实现方式）。
依赖注入（DI）：IoC的一种实现方式，用来反转依赖（IoC的具体实现方式）。
IoC容器：依赖注入的框架，用来映射依赖，管理对象创建和生存周期（DI框架）。
三、Ioc的类型
IOC的实现有三种方式
构造注入：就是将开头例子中的Setter方式，在创建客户对象的时候，初始化进入。
Setter注入：就是开头的例子。
依赖获取。就是在注入的时候，利用一下虚拟工厂（Abstract Factory），这种适用于服务不仅一种的时候，比如我们赋予闹钟报时功能。
1、构造函数注入
public Class SayHello
{
private IPeople _people;
public SayHello(IPeople p) {
_people=p;
} public void Say()
{
_people.Say(); } }
2、属性注入
using Microsoft.VisualStudio.TestTools.UnitTesting;
using VisionLogic.Training.DependencyInjection.Scenario;
namespace VisionLogic.Training.DependencyInjection.Scenario.UnitTest
{
[TestClass]
public class SetterInjectionTest
{
class Client
{
private IWeatherReader reader;
public IWeatherReader Reader
{
get { return reader; }
set { reader = value; }
}
} [TestMethod]
public void Test()
{
IWeatherReader reader = new Assembler<IWeatherReader>().Create();
Client client = new Client();
client.Reader = reader;
Assert.IsNotNull(client.Reader);
}
}
}
也可以写一个Setter方法
3、接口注入
using Microsoft.VisualStudio.TestTools.UnitTesting;
using VisionLogic.Training.DependencyInjection.Scenario;
namespace VisionLogic.Training.DependencyInjection.Scenario.UnitTest
{
[TestClass]
public class InterfaceInjectionTest
{
interface IClientWithWeatherReader
{
IWeatherReader Reader { get; set;}
} class Client : IClientWithWeatherReader
{
private IWeatherReader reader; #region IClientWithWeatherReader Members
public IWeatherReader Reader
{
get { return reader; }
set { reader = value; }
}
#endregion
} [TestMethod]
public void Test()
{
IWeatherReader reader = new Assembler<IWeatherReader>().Create();
Client client = new Client();
IClientWithWeatherReader clientWithReader = client;
clientWithReader.Reader = reader;
Assert.IsNotNull(clientWithReader.Reader);
}
}
}
4、依赖获取
public interface ISayMorning
{ void SayMorning();
} public class ChinesePosition:ISayMorning
{
void SayMorning()
{
Console.Writeline("早安！");
}
} public class EnglishPosition:ISayMorning
{
void SayMorning()
{
Console.Writeline("GoodMorning!");
}
} public interface IFactory
{
ISayTime MakeTimeSayer();
ISayMoring MakeMorningSayer();
} public class FactoryAmerican:IFactory
{
public ISayTime MakeTimeSayer()
{
return new EnglishPositionTime(); //未实现
}
public ISayMoring MakeMorningSayer()
{
return new EnglishPosition();
}
} //位于中国的工厂
public class FactoryChinese:IFactory
{
public ISayTime MakeTimeSayer()
{
return new ChinesePositionTime(); //未实现
}
public ISayMoring MakeMorningSayer()
{
return new ChinesePosition();
}
} public statics class FactoryContainer
{
static FactoryContainer()
{
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.Load("Config.xml");
XmlNode xmlNode =xmlDoc.ChildNodes[].ChildNodes[].ChildNodes[]; if ("Chinese" == xmlNode.Value)
{
factory = new FactoryChinese();
}
else if ("American" == xmlNode.Value)
{
factory = new FactoryAmerican();
}
else
{
throw new Exception("Factory Init Error");
}
}
}
} //调用
IFactory factory = FactoryContainer.factory;
IWindow window = factory.SayMorning();
这样，我们可以用过xml文件配置工厂（也就是不同的定位条件）。
四、一个例子
C#
using System;
namespace VisionLogic.Training.DependencyInjection.Scenario.Attributer
{
/// <summary>
/// 抽象的处理对象
/// </summary>
public interface IObjectWithGuid
{
string Guid { get; set;}
}
}定义需要注入的限制接口，并用一个Attribute管理它
C#
using System;
namespace VisionLogic.Training.DependencyInjection.Scenario.Attributer
{
/// <summary>
/// 需要注入的用以限制最大数量的接口
/// </summary>
public interface ICapacityConstraint
{
int Max { get;}
}
public class CapacityConstraint : ICapacityConstraint
{
private int max;
public CapacityConstraint(){this.max = 0;} // 默认情况下不限制
public CapacityConstraint(int max) { this.max = max; }
public int Max { get { return max; } }
}
[AttributeUsage(AttributeTargets.Class, AllowMultiple = false)]
public class ConstraintAttribute : Attribute
{
private ICapacityConstraint capacity;
public ConstraintAttribute(int max) { this.capacity = new CapacityConstraint(max); }
public ConstraintAttribute() { this.capacity = null; }
public ICapacityConstraint Capacity { get { return capacity; } }
}
} Assembler上增加通过Attribute注入限制的响应。
using System;
using System.Collections.Generic;
namespace VisionLogic.Training.DependencyInjection.Scenario.Attributer
{
public class Assembler
{
/// <summary>
/// 登记相关类型对“最大容量”属性的使用情况
/// </summary>
private IDictionary<Type, ConstraintAttribute> attributeRegistry = new Dictionary<Type, ConstraintAttribute>();
/// <summary>
/// 登记每个类型（如须受到“最大容量”属性限制的话），实际已经创建的对象数量
/// </summary>
private IDictionary<Type, int> usageRegistry = new Dictionary<Type, int>();
public T Create<T>() where T : IObjectWithGuid, new()
{
ICapacityConstraint constraint = GetAttributeDefinedMax(typeof(T));
if ((constraint == null) || (constraint.Max <= 0)) // max <= 0 代表是不需要限制数量的。
return InternalCreate<T>();
else
{
if (usageRegistry[typeof(T)] < constraint.Max) // 检查是否超出容量限制
{
usageRegistry[typeof(T)]++; // 更新使用情况注册信息
return InternalCreate<T>();
}
else
return default(T);
}
}
// helper method
// 直接生成特定实例，并setter 方式注入其guid。
private T InternalCreate<T>()
where T : IObjectWithGuid, new()
{
T result = new T();
result.Guid = Guid.NewGuid().ToString();
return result;
}
/// helper method.
// 获取特定类型所定义的最大数量, 同时视情况维护attributeRegistry 和usageRegistry 的注册信息。
private ICapacityConstraint GetAttributeDefinedMax(Type type)
{
ConstraintAttribute attribute = null;
if (!attributeRegistry.TryGetValue(type, out attribute)) //新的待创建的类型
{
// 填充相关类型的“最大容量”属性注册信息
object[] attributes = type.GetCustomAttributes(typeof(ConstraintAttribute), false);
if ((attributes == null) || (attributes.Length <= 0))
attributeRegistry.Add(type, null);
else
{
attribute = (ConstraintAttribute)attributes[0];
attributeRegistry.Add(type, attribute);
usageRegistry.Add(type, 0); // 同时补充该类型的使用情况注册信息
}
}
if (attribute == null)
return null;
else
return attribute.Capacity;
}
}
} 4.2对方案的测试
using Microsoft.VisualStudio.TestTools.UnitTesting;
using VisionLogic.Training.DependencyInjection.Scenario.Attributer;
namespace VisionLogic.Training.DependencyInjection.Scenario.UnitTest.Attributer
{
[TestClass()]
public class AssemblerTest
{
public abstract class ObjectWithGuidBase : IObjectWithGuid
{
protected string guid;
public virtual string Guid
{
get { return guid; }
set { guid = value; }
}
}
[Constraint(2)] // 通过属性注入限制
public class ObjectWithGuidImplA : ObjectWithGuidBase { }
[Constraint(0)] // 通过属性注入限制
public class ObjectWithGuidImplB : ObjectWithGuidBase { }
[Constraint(-5)] // 通过属性注入限制
public class ObjectWithGuidImplC : ObjectWithGuidBase { }
public class ObjectWithGuidImplD : ObjectWithGuidBase { }
[TestMethod]
public void Test()
{
Assembler assembler = new Assembler();
for (int i = 0; i < 2; i++)
Assert.IsNotNull(assembler.Create<ObjectWithGuidImplA>());
Assert.IsNull(assembler.Create<ObjectWithGuidImplA>()); // 最多两个
for (int i = 0; i < 100; i++)
Assert.IsNotNull(assembler.Create<ObjectWithGuidImplB>()); // 不限制
for (int i = 0; i < 100; i++)
Assert.IsNotNull(assembler.Create<ObjectWithGuidImplC>()); // 不限制
for (int i = 0; i < 100; i++)
Assert.IsNotNull(assembler.Create<ObjectWithGuidImplD>()); // 不限制
}
}
}