前言
最近在调试EasyNetQ代码的时候发现里面有一段代码，就是IoC容器的简单实现，跟着他的代码敲了一遍，发现了奇妙之处。当然也是因为我才疏学浅导致孤陋寡闻了。他的思路就是通过动态调用构造函数生成对象，然后将对象保存，调用的时候进行单例调用，而且，代码中不会存在 new 字眼。所有实例对象的创建和映射都在容器中实现。当然，还是用第三方的容器比较稳妥，本文中只是很简单的一个示范。具体理解的是否正确，我也不敢说，只不过，能达到一些预期的效果，功能不够强大。
解析
首先，我们先添加几个接口。IServiceProvider，IServiceRegister，IServiceContainer （继承自前两个）
/// <summary>
/// 服务提供接口
/// </summary>
public interface IServiceProvider
{
/// <summary>
/// 获取某个类型的服务实例
/// </summary>
/// <typeparam name="TService"> TService 接口 </typeparam>
/// <returns>返回TService类型实例</returns>
TService Resolve<TService>() where TService : class;
}
/// <summary>
/// 服务注册接口
/// </summary>
public interface IServiceRegister
{
/// <summary>
/// 注册一个服务工厂
/// </summary>
/// <typeparam name="TService">工厂类</typeparam>
/// <param name="serviceCreator">创建一个新的接口实例</param>
/// <returns>返回当前注册工厂,以便调用其他的register方法</returns>
IServiceRegister Register<TService>(Func<IServiceProvider, TService> serviceCreator) where TService : class;
/// <summary>
/// 注册服务类型和服务实例
/// </summary>
/// <typeparam name="TService">接口实例</typeparam>
/// <typeparam name="TImplementation">类型继承自TService</typeparam>
/// <returns>返回当前注册工厂,以便调用其他的register方法</returns>
IServiceRegister Register<TService, TImplementation>()
where TService : class
//TImplementation 继承自 TService
where TImplementation : class, TService;
}
/// <summary>
/// 对外接口Container，继承自IServiceProvider,IServiceRegister
/// </summary>
public interface IServiceContainer : IServiceProvider, IServiceRegister { }
当然，最主要的还是 IServiceContainer 的实现，代码中有简单的注释，所以我就直接贴代码了。（看不懂的仔细认真一些就好）
/// <summary>
/// 服务提供类的实现，类似服务工厂
/// </summary>
public class ServiceProvider : IServiceContainer
{
/// <summary>
/// 锁
/// </summary>
private readonly object syncLock = new object();
/// <summary>
/// 存储单例工厂
/// </summary>
private readonly ConcurrentDictionary<Type, object> factories = new ConcurrentDictionary<Type, object>();
/// <summary>
/// 存储注册类型
/// </summary>
private readonly ConcurrentDictionary<Type, Type> registrations = new ConcurrentDictionary<Type, Type>();
/// <summary>
/// 存储实例
/// </summary>
private readonly ConcurrentDictionary<Type, object> instances = new ConcurrentDictionary<Type, object>();
#region 私有方法
/// <summary>
/// 判断服务是否已经被注册过
/// </summary>
/// <param name="serviceType"></param>
/// <returns></returns>
private bool ServiceIsRegistered(Type serviceType)
{
//判断是否在工厂或者注册库内已经注册过该类型
return factories.ContainsKey(serviceType) || registrations.ContainsKey(serviceType);
}
#endregion
/// <summary>
/// 注册工厂
/// </summary>
/// <typeparam name="TService"></typeparam>
/// <param name="serviceCreator"></param>
/// <returns></returns>
public IServiceRegister Register<TService>(Func<IServiceProvider, TService> serviceCreator) where TService : class
{
lock (syncLock) {
var serviceType = typeof(TService);
if (ServiceIsRegistered(serviceType)) { return this; }
//将服务添加到存储器中
factories.TryAdd(serviceType, serviceCreator);
return this;
}
}
/// <summary>
/// 注册实例类
/// </summary>
/// <typeparam name="TService">IService 必须实现一个构造器</typeparam>
/// <typeparam name="TImplementation"></typeparam>
/// <returns></returns>
public IServiceRegister Register<TService, TImplementation>() where TService : class where TImplementation : class, TService
{
lock (syncLock)
{
var serviceType = typeof(TService);
var implType = typeof(TImplementation);
if (ServiceIsRegistered(serviceType)) { return this; }
//如果注册的类不是继承自TService接口，抛出异常
if (!serviceType.IsAssignableFrom(implType))
{
throw new Exception(string.Format("类型 {0} 不继承接口 {1}", implType.Name, serviceType.Name));
}
//获取构造方法，必须只有一个构造方法（why？）
var constructors = implType.GetConstructors();
if (constructors.Length != 1)
{
throw new Exception(string.Format("服务实例必须有且只有一个构造方法.当前实例 {0} 拥有 {1} 个", implType.Name, constructors.Length.ToString()));
}
//添加
registrations.TryAdd(serviceType, implType);
return this;
}
}
/// <summary>
/// 返回一个实例
/// </summary>
/// <typeparam name="TService"></typeparam>
/// <returns></returns>
public virtual TService Resolve<TService>() where TService : class
{
var serviceType = typeof(TService);
object service;
//如果实例存储器中已经存在该实例，直接返回
if (instances.TryGetValue(serviceType, out service))
return (TService)service;
lock (syncLock)
{
//加锁，再次判断
if (instances.TryGetValue(serviceType, out service))
{
return (TService)service;
}
//如果注册器中存在该类型，创建该实例，并加入到实例存储器中
if (registrations.ContainsKey(serviceType))
{
var implementationType = registrations[serviceType];
service = CreateServiceInstance(implementationType);
instances.TryAdd(serviceType, service);
}
else if (factories.ContainsKey(serviceType))
{
service = ((Func<IServiceProvider, TService>)factories[serviceType])(this);
instances.TryAdd(serviceType, service);
}
else
{
throw new Exception(string.Format("服务类型 {0} 未注册", serviceType.Name));
}
return (TService)service;
}
}
private object Resolve(Type serviceType)
{
return GetType()
.GetMethod("Resolve", new Type[0])
.MakeGenericMethod(serviceType)
.Invoke(this, new object[0]);
}
private object CreateServiceInstance(Type implementationType)
{
//获取构造器
var constructors = implementationType.GetConstructors();
//遍历构造器中的参数类型，获取参数
var parameters = constructors[0]
.GetParameters()
.Select(parameterInfo => Resolve(parameterInfo.ParameterType))
.ToArray();
//创建实例方法
return constructors[0].Invoke(parameters);
}
}
调用方式
写个测试：IAnimal 接口中有Shout方法。在创建两个类继承自IAnimal，Dog，Cat。 IPeople中有个Pet方法，在创建两个类，Man，Women 继承自IPeople。 其中IPeople中初始化要传入IAnimal的实例，来确定养的宠物是猫还是狗.
代码如下：
public interface IAnimal
{
void Shout();
}
public class Dog : IAnimal
{
public void Shout()
{
Console.WriteLine("汪汪汪");
}
}
public class Cat : IAnimal
{
public void Shout()
{
Console.WriteLine("喵喵喵");
}
}
public interface IPeople
{
void Pet();
}
public class Man : IPeople
{
private IAnimal _animal;
public Man(IAnimal animal)
{
_animal = animal;
}
public void Pet()
{
Console.WriteLine("[男]我有一个宠物，它在：");
_animal.Shout();
}
}
public class Woman : IPeople
{
private IAnimal _animal;
public Woman(IAnimal animal)
{
_animal = animal;
}
public void Pet()
{
Console.WriteLine("[女]我有一个宠物，它在：");
_animal.Shout();
}
}
测试代码
static void Main(string[] args)
{
Func<IServiceContainer> getContainer = () => new ServiceProvider();
IServiceContainer container = getContainer();
//注册
container.Register(_ => container)
//注册Dog实例
.Register<IAnimal, Dog>()
//注册Woman实例
.Register<IPeople, Woman>();
//得到people
var people = container.Resolve<IPeople>();
//调用pet方法
people.Pet();
Console.Read();
}
执行结果：
同样，当我们把 Dog换成Cat
我们把animal的注册去掉，由于people依赖于animal，所以会报错误。
总结
这是一个简单的IoC容器的实现，相信真正的要复杂的很多，不过看EasyNetQ就直接这么用的，我觉得如果需求不高的话，也可以用这种方法。而且，代码看起来清洁了许多，不用自己new对象，而且，内部依赖也可以轻松解决。我该去看看真正的容器是怎么实现的了，byebye
时间： 2024-10-26 01:35:56