ASP.NET Core 中的 ServiceProvider
前言#
在 ASP.NET Core 中，微软提供了一套默认的依赖注入实现，该实现对应的包为：Microsoft.Extensions.DependencyInjection，我们可以通过查看其对应的开源仓库看一下它的具体实现。基于该实现，我们不必显式创建我们的服务对象，可以将其统一注入到 ServiceProvider 中进行集中维护，使用的时候直接在该对象中获取即可。让我们在编写业务逻辑时，不用太关注对象的创建和销毁。这也是为什么现在有些最佳实践中建议不要过多使用 New 的方式来获取对象。在本文中，我们将一起了解一下如何实现一个自己的 ServiceProvider。
自己动手，丰衣足食#
为了方便区分，我这里自定义定义的类叫：ServiceLocator，其功能与官方的 ServiceProvider 类似。
基本实现#
首先，我们需要定义一个简单的服务发现接口，用于约束上层具体的实现，示例代码如下所示：
Copy
public interface IServiceLocator
{
void AddService
T GetService
}
接着，我们定义一个继承上述接口的具体实现类，示例代码如下所示：
Copy
public class ServiceLocator : IServiceLocator
{
private readonly IDictionary
public ServiceLocator()
{
services = new Dictionary
}
public void AddService
{
services.TryAdd(typeof(T), Activator.CreateInstance
}
public T GetService
{
try
{
return (T)services[typeof(T)];
}
catch (KeyNotFoundException)
{
throw new ApplicationException("The requested service is not registered");
}
}
}
这样，我们就实现了一个最基本的服务发现类，通过该类，我们可以将我们的多个服务进行集中管理。这里我为了方便，模拟了 3 个服务类用于注册，示例代码如下所示：
Copy
public interface IService
{
void SayHello();
}
public class ServiceA : IService
{
public void SayHello()
{
Console.WriteLine("Hello,I'm from A");
}
}
public class ServiceB : IService
{
public void SayHello()
{
Console.WriteLine("Hello,I'm from B");
}
}
public class ServiceC : IService
{
public void SayHello()
{
Console.WriteLine("Hello,I'm from C");
}
}
使用方式就很简单了，如下所示：
Copy
class Program
{
static void Main(string[] args)
{
IServiceLocator locator = new ServiceLocator();
locator.AddService
locator.AddService
locator.AddService
locator.GetService
locator.GetService
locator.GetService
}
}
程序运行效果如下图所示：
程序看起来运行不错，结果也符合我们的预期。但是稍微有点工作经验的朋友就会发现上述的实现是有很多潜在问题的。对于 IServiceLocator 的实例，我们一般会以单例模式来进行使用，这就会设计到线程安全的委托，所以我们的服务列表必须要是线程安全的。此外，如果我们需要注册的服务过多，通过上述方式来进行注册的话会加到系统开销，因为我们的服务一旦注册进去就会立刻被初始化，从而耗费不必要的系统内存，所以我们应该让其实例化推迟，在使用的时候才进行实例化操作。下面我们对上述问题一一进行改进。
单例模式#
单例模式是一种最简单也是使用最频繁的设计模式，单例模式本身也有很多形式，感兴趣的可以查看我之前的博文：设计模式系列 - 单例模式，这里，我采用 线程安全 方式来修改我们的 ServiceLocator，此外，我们还需要将我们的服务集合类修改为线程安全类型。所以，整个修改完毕后，示例代码如下所示：
Copy
public class ServiceLocator : IServiceLocator
{
private static ServiceLocator _instance;
private static readonly object _locker = new object();
public static ServiceLocator GetInstance()
{
if (_instance =www.tongyayuLe.cn= null)
{
lock (_locker)
{
if (_instance == null)
{
_instance = new ServiceLocator();
}
}
}
return _instance;
}
private readonly IDictionary
private ServiceLocator()
{
services = new ConcurrentDictionary
}
public void AddService
{
services.TryAdd(typeof(T), Activator.CreateInstance
}
public T GetService
{
try
{
return (T)services[typeof(T)];
}
catch (KeyNotFoundException)
{
throw new ApplicationException("The requested service is not registered");
}
}
}
延迟加载#
要想让所有的注册的服务支持懒加载，我们需要引入一个新的集合，这个新的集合是用于存储我们相应的实例对象，在注册的时候我们只记录注册类型，在需要访问到相应的服务时，我们只需要在这个实例集合列表中访问，如果发现我们需要的服务还未被实例化，那我们再进行实例化，然后将该实例化对象存储起来并返回。对于用哪种数据结构来存，我们可以采用多种数据结构，我这里仍然采用字典来存储，示例代码如下所示：
Copy
public class ServiceLocator : IServiceLocator
{
private static ServiceLocator _instance;
private static readonly object _locker = new object();
public static ServiceLocator GetInstance()
{
if (www.zongxyuLe.com_instance == null)
{
lock (_locker)
{
if (_instance == null)
{
_instance = new ServiceLocator();
}
}
}
return _instance;
}
private readonly IDictionary
private readonly IDictionary
private ServiceLocator(www.yuanhuapt.cn)
{
servicesType = new ConcurrentDictionary
instantiatedServices = new ConcurrentDictionary
}
public void AddService
{
servicesType.Add(typeof(T), typeof(T));
}
public T GetService
{
if (!instantiatedServices.ContainsKey(typeof(T)))
{
try
{
ConstructorInfo constructor = servicesType[typeof(T)].GetConstructor(new Type[0]);
Debug.Assert(constructor !www.yasenyuLee.cn = null, "Cannot find a suitable constructor for " + typeof(T));
T service = (T)constructor.Invoke(null);
instantiatedServices.Add(typeof(T), service);
}
catch (KeyNotFoundException)
{
throw new ApplicationException("The requested service is not registered");
}
}
return (T)instantiatedServices[typeof(T)];
}
}
自匹配构造#
上面的所有改进都支持无参构造函数的服务，但是对于有参构造函数的服务注册，我们定义的 服务提供者就不满足的，因为上述的反射方式是不支持有参构造函数的。对于这种情况我们有两种解决办法。第一种是将服务的初始化放到最上层，然后 ServiceLocator 通过一个 Fun 的方式来获取该示例，并存储起来，我们称之为 显示创建。第二种方式依然是通过反射方式，只是这个反射可能会复杂一下,我们称之为 隐式创建。我们分别对于这两个实现方式进行代码示例。
显示构造
Copy
public interface IServiceLocator
{
void AddService
//新增接口
void AddService
T GetService
}
public class ServiceLocator : IServiceLocator
{
private static ServiceLocator _instance;
private static readonly object _locker = new object();
public static ServiceLocator GetInstance()
{
if (_instance == null)
{
lock (_locker)
{
if (_instance == null)
{
_instance = new ServiceLocator();
}
}
}
return _instance;
}
private readonly IDictionary
private readonly IDictionary
private ServiceLocator()
{
servicesType = new ConcurrentDictionary
instantiatedServices = new ConcurrentDictionary
}
public void AddService
{
servicesType.Add(typeof(T), typeof(T));
}
//新增接口对应的具体实现
public void AddService
{
servicesType.Add(typeof(T), typeof(T));
var done = instantiatedServices.TryAdd(typeof(T), Implementation());
Debug.Assert(done, "Cannot add current service: " + typeof(T));
}
public T GetService
{
if (!instantiatedServices.ContainsKey(typeof(T)))
{
try
{
ConstructorInfo constructor = servicesType[typeof(T)].GetConstructor(new Type[0]);
Debug.Assert(constructor != null, "Cannot find a suitable constructor for " + typeof(T));
T service = (T)constructor.Invoke(null);
instantiatedServices.Add(typeof(T), service);
}
catch (KeyNotFoundException)
{
throw new ApplicationException("The requested service is not registered");
}
}
return (T)instantiatedServices[typeof(T)];
}
}
-------------------------------------------------------------------------------------------
public interface IService
{
void SayHello();
}
public class ServiceA : IService
{
public void SayHello()
{
Console.WriteLine("Hello,I'm from A");
}
}
public class ServiceB : IService
{
public void SayHello()
{
Console.WriteLine("Hello,I'm from B");
}
}
public class ServiceC : IService
{
public void SayHello()
{
Console.WriteLine("Hello,I'm from C");
}
}
public class ServiceD : IService
{
private readonly IService _service;
public ServiceD(IService service)
{
_service = service;
}
public void SayHello()
{
Console.WriteLine("-------------");
_service.SayHello();
Console.WriteLine("Hello,I'm from D");
}
}
-------------------------------------------------------------------------------------------
class Program
{
static void Main(string[] args)
{
IServiceLocator locator = ServiceLocator.GetInstance();
locator.AddService
locator.AddService
locator.AddService
locator.GetService
locator.GetService
locator.GetService
locator.AddService(() => new ServiceD(locator.GetService
locator.GetService
}
}
程序输出如下图所示：
当我们需要注册的服务对应的有参构造函数中的参数不需要注册到 ServiceLocator，那我们可以采用这种方法进行服务注册，比较灵活。
隐式构造
Copy
public class ServiceLocator : IServiceLocator
{
private static ServiceLocator _instance;
private static readonly object _locker = new object();
public static ServiceLocator GetInstance()
{
if (_instance == null)
{
lock (_locker)
{
if (_instance == null)
{
_instance = new ServiceLocator();
}
}
}
return _instance;
}
private readonly IDictionary
private readonly IDictionary
private ServiceLocator()
{
servicesType = new ConcurrentDictionary
instantiatedServices = new ConcurrentDictionary
}
public void AddService
{
servicesType.Add(typeof(T), typeof(T));
}
public void AddService
{
servicesType.Add(typeof(T), typeof(T));
var done = instantiatedServices.TryAdd(typeof(T), Implementation());
Debug.Assert(done, "Cannot add current service: " + typeof(T));
}
public T GetService
{
var service = (T)GetService(typeof(T));
if (service == null)
{
throw new ApplicationException("The requested service is not registered");
}
return service;
}
///
/// 关键代码
///
///
///
private object GetService(Type type)
{
if (!instantiatedServices.ContainsKey(type))
{
try
{
ConstructorInfo constructor = servicesType[type].GetTypeInfo().DeclaredConstructors
.Where(constructor => constructor.IsPublic).FirstOrDefault();
ParameterInfo[] ps = constructor.GetParameters();
List