实现一个简易IOC容器
本文，实现了一个简易的IOC容器，主要供学习使用。
首先抽象需要实现的功能，容器主要由两部分组成
1.注册
2.获取实例
/// <summary>
/// 注册 基类/接口->实际类型
/// </summary>
/// <typeparam name="T"></typeparam>
/// <typeparam name="TReal"></typeparam>
void Register<T, TReal>();
/// <summary>
/// 注册 实例
/// </summary>
/// <typeparam name="obj"></typeparam>
void RegisterInstances(object obj);
/// <summary>
/// 注册 实例
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="obj"></param>
void RegisterInstances<T>(object obj);
/// <summary>
/// 注册 泛型
/// “开放”类型 只能存在于typeof操作中
/// </summary>
/// <param name="t1"></param>
/// <param name="t2"></param>
void RegisterGeneric(Type t1, Type t2);
/// <summary>
/// 获取类型实例
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
T GetInstances<T>();
为了简单起见，本文使用静态的Dictionary作为存放容器，XML配置部分未实现，
具体实现如下
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Reflection;
namespace Core.IOC
{
public class IOCManage
{
/// <summary>
/// 多构造函数 创建对象规则
/// 默认为 MultipleCtor.Longest
/// </summary>
public static MultipleCtor MultipleType = MultipleCtor.Longest;
/// <summary>
/// 类型字典 存放 声明类型->实际类型
/// </summary>
private static Dictionary<Type, Type> _types = new Dictionary<Type, Type>();
/// <summary>
/// 实例字典
/// </summary>
private static Dictionary<Type, object> _instances = new Dictionary<Type, object>();
static IOCManage()
{
//TODO:XML配置加载
}
/// <summary>
/// 创建类型
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
public static T GetInstances<T>()
{
return (T)Get(typeof(T));
}
/// <summary>
/// 该方法供 属性注入 中递归调用
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
private static object Get(Type type)
{
object obj = InjectCtor(type);
InjectProperty(obj);
return obj;
}
#region 构造器注入
/// <summary>
/// 构造器注入
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
private static object InjectCtor(Type type)
{
//查找 对象字典中是否有现成对象可以使用
object obj;
if (_instances.TryGetValue(type, out obj))
return obj;
//查找 类型字典 获取要创建的实际类型
Type t = GetRealType(type);
if (t == null || !t.IsClass || t.IsAbstract) return null;
//对构造函数的几种处理方法
ConstructorInfo[] ctors = t.GetConstructors();
if (ctors.Length == 0)
{
//throw new MissingMethodException("找不到匹配的公共构造函数");
}
else if (ctors.Length == 1)
{
obj = CreateObj(t, ctors[0]);
}
else if (ctors.Length > 1)
{
if (MultipleType == MultipleCtor.Error) { throw new CtorMultipleException("构造函数多余一个！"); }
if (MultipleType == MultipleCtor.Attribute)
{
foreach (var ctor in ctors)
{
if (ctor.IsDefined(typeof(AutoCtorAttribute), false))
{
obj = CreateObj(t, ctor);
if (obj != null) break;
}
}
}
if (MultipleType == MultipleCtor.Longest || obj == null)//如果标记为特性模式 却创建失败，重新执行
{
var _ctors = ctors.OrderByDescending(a => a.GetParameters().Length);
foreach (var ctor in _ctors)
{
obj = CreateObj(t, ctor);
if (obj != null) break;
}
}
}
_instances[type] = obj;
return obj;
}
/// <summary>
/// 查找实际类型
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
private static Type GetRealType(Type type)
{
Type t;
if (!_types.TryGetValue(type, out t))//查找 类型字典，找出实际要创建的类型
{
t = GetGenericType(type);
}
return t;
}
/// <summary>
/// 获取泛型类型
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
private static Type GetGenericType(Type type)
{
//假设 字典中存的是 typeof(IList<>)->typeof(List<>)
//现在需要从IList<string>创建List<string>对象
Type t = null;
if (type.IsGenericType)
{
if (_types.TryGetValue(type.GetGenericTypeDefinition(), out t) && t.IsGenericType)//获取“开放” 类型 字典中查找
{
t = t.MakeGenericType(type.GetGenericArguments());//获取 实际需要创建的“封闭”类型
}
}
return t;
}
/// <summary>
/// 通过构造函数类型创建实例
/// </summary>
/// <param name="type"></param>
/// <param name="t"></param>
/// <param name="ctor"></param>
/// <returns></returns>
private static object CreateObj(Type type, ConstructorInfo ctor)
{
ParameterInfo[] @params = ctor.GetParameters();
int length = @params.Length;
object[] args = new object[length];
for (int i = 0; i < length; i++)
{
args[i] = InjectCtor(@params[i].ParameterType);//获取参数类型 递归调用创建方法
}
try
{
return Activator.CreateInstance(type, args);
}
catch
{
return null;
}
}
#endregion
#region 属性注入
/// <summary>
/// 属性注入
/// 通过[AutoWrite]特性标记
/// </summary>
/// <param name="obj"></param>
private static void InjectProperty(object obj)
{
if (obj != null)
{
PropertyInfo[] properties = obj.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance);//只查找公开属性
foreach (var property in properties)
{
AutoWriteAttribute autoWrite = (AutoWriteAttribute)Attribute.GetCustomAttribute(property, typeof(AutoWriteAttribute));
if (autoWrite != null)
{
object value = Get(autoWrite.RealType);
InjectProperty(obj);//递归注入
property.SetValue(obj, value, null);
}
}
}
}
#endregion
#region 注册
/// <summary>
/// 注册 基类/接口->实际类型
/// </summary>
/// <typeparam name="T"></typeparam>
/// <typeparam name="TReal"></typeparam>
public static void Register<T, TReal>() where TReal : T
{
_types[typeof(T)] = typeof(TReal);
}
/// <summary>
/// 注册 类型
/// </summary>
/// <typeparam name="T"></typeparam>
public static void RegisterType<T>()
{
_types[typeof(T)] = typeof(T);
}
/// <summary>
/// 注册 实例
/// </summary>
/// <typeparam name="T"></typeparam>
public static void RegisterInstances(object obj)
{
if (obj == null) throw new ArgumentNullException("obj 不能为null！");
_instances[obj.GetType()] = obj;
}
/// <summary>
/// 注册 实例
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="obj"></param>
public static void RegisterInstances<T>(object obj)
{
Type type = typeof(T);
Type t = obj.GetType();
if (!type.IsAssignableFrom(t)) //判断obj类型是否 等于/继承/实现 T
{
throw new RegisterException(string.Format("obj的实际类型{0}与泛型类型{1}不匹配！", t.Name, type.Name));
}
_instances[type] = obj;
}
/// <summary>
/// 注册 泛型
/// “开放”类型 只能存在于typeof操作中
/// </summary>
/// <param name="t1"></param>
/// <param name="t2"></param>
public static void RegisterGeneric(Type t1, Type t2)
{
//判断t1是否 等于/继承/实现t2
//if (!t1.IsAssignableFrom(t2))
//{
Type _t1 = t1;
Type _t2 = t2;
//if (t1.IsGenericTypeDefinition || t2.IsGenericTypeDefinition)//泛型特殊处理
//{
//TODO:判断泛型是否存在 继承 实现 关系
//通过创建泛型的“封闭”类型判断继承关系
//todo:暂时实现不了
//Type _t1 = t1.MakeGenericType(typeof(object));//泛型约束
//Type _t2 = t2.MakeGenericType(typeof(object));//泛型约束
//if (!_t1.IsAssignableFrom(_t2))
//{
// throw new RegisterException(string.Format("参数类型{0}与{1}不匹配！", t1.Name, t2.Name));
//}
//}
//else
//{
//throw new RegisterException(string.Format("参数类型{0}与{1}不匹配！", t1.Name, t2.Name));
//}
//}
_types[t1] = t2;
}
#endregion
}
}
其中使用到的相关类
public class AutoWriteAttribute : Attribute
{
public Type RealType { get; private set; }
public AutoWriteAttribute(Type type) { this.RealType = type; }
}
public class AutoCtorAttribute : Attribute
{
}
public class CtorMultipleException : Exception
{
public CtorMultipleException(string message) : base(message) { }
}
/// <summary>
/// 针对多个构造函数的创建方法
/// </summary>
public enum MultipleCtor
{
/// <summary>
/// 按照 参数数量 依次调用构造函数 直到创建成功
/// </summary>
Longest,
/// <summary>
/// 抛出CtorMultipleException异常
/// </summary>
Error,
/// <summary>
/// 优先使用特性标记的构造函数 然后按照 Longest;
/// </summary>
Attribute
}
public class RegisterException : Exception
{
public RegisterException(string message) : base(message) { }
}
test
class Program
{
static void Main(string[] args)
{
IOCManage.RegisterInstances(new A { Name = "A" });
IOCManage.RegisterInstances<B>(new B { Name = "B" });
IOCManage.RegisterType<C>();
C c = IOCManage.GetInstances<C>();
Console.Read();
}
}
class A { public string Name { get; set; } }
class B { public string Name { get; set; } }
class C
{
private A a;
private B b;
public C(A a, B b)
{
this.a = a;
this.b = b;
}
}
