手把手教你写DI_3_小白徒手支持 `Singleton` 和 `Scoped` 生命周期
手把手教你写DI_3_小白徒手支持 Singleton 和 Scoped 生命周期
浑身绷带的小白同学：我们继续开展我们的工作，大家都知道 Singleton是什么，就是全局只有一个呗，我们就先从它开始，这个多简单，我们找个字典放这些对象就ok啦
public class ServiceProvider : IServiceProvider
{
...
private readonly ConcurrentDictionary<Type, object> singletonCache = new ConcurrentDictionary<Type, object>();
public object GetService(Type serviceType)
{
case Lifetime.Singleton:
singletonCache.GetOrAdd(serviceType, x =>
{
if(defintion is DelegateServiceDefintion defi)
{
return defi.ImplementationFactory(this);
}
else
{
ConstructorInfo constructor = cache.GetOrAdd(serviceType, i =>
{
var d = defintion as TypeServiceDefintion;
var implementationType = serviceType.IsConstructedGenericType
? d.ImplementationType.MakeGenericType(serviceType.GenericTypeArguments)
: d.ImplementationType;
return implementationType.GetConstructors().FirstOrDefault(i => i.IsPublic);
});
ar ps = constructor.GetParameters();
var args = new object[ps.Length];
for (int j = 0; j < ps.Length; j++)
{
var p = ps[j];
args[j] = i.GetService(p.ParameterType); // 小白同学: 获取参数值
}
return constructor.Invoke(args); // 小白同学: 创建;
}
});
....
case Lifetime.Transient:
.....
....
}
}
大神：我的刀呢？
小白同学：我错啦！！！
public class ServiceProvider : IServiceProvider
{
...
private readonly ConcurrentDictionary<Type, object> singletonCache = new ConcurrentDictionary<Type, object>();
public object GetService(Type serviceType)
{
case Lifetime.Singleton:
return singletonCache.GetOrAdd(serviceType, x => CreateObj(x));
case Lifetime.Scoped:
return CreateObj(x);
case Lifetime.Transient:
return CreateObj(x);
....
}
public object CreateObj(Type serviceType)
{
if(defintion is DelegateServiceDefintion defi)
{
return defi.ImplementationFactory(this);
}
else
{
ConstructorInfo constructor = cache.GetOrAdd(serviceType, i =>
{
var d = defintion as TypeServiceDefintion;
var implementationType = serviceType.IsConstructedGenericType
? d.ImplementationType.MakeGenericType(serviceType.GenericTypeArguments)
: d.ImplementationType;
return implementationType.GetConstructors().FirstOrDefault(i => i.IsPublic);
});
ar ps = constructor.GetParameters();
var args = new object[ps.Length];
for (int j = 0; j < ps.Length; j++)
{
var p = ps[j];
args[j] = i.GetService(p.ParameterType); // 小白同学: 获取参数值
}
return constructor.Invoke(args); // 小白同学: 创建;
}
}
}
小白同学：好了，我们来说下 Scoped 作用域，百度百科的解释是这样的: 作用域（scope），程序设计概念，通常来说，一段程序代码中所用到的名字并不总是有效/可用的，而限定这个名字的可用性的代码范围就是这个名字的作用域。
作用域的使用提高了程序逻辑的局部性，增强程序的可靠性，减少名字冲突。
对于对象而言（其他也是一样的），在main函数中，对象的作用域为他所在的最近的一对花括号内。在后花括号处析构函数被调用；全局的对象的作用域为声明之后的整个文件，析构函数在最后被调用。另外，临时产生的对象在使用完后立即会被析构。
小白同学：虽然比较奇怪为啥百度百科强调的是名字，名字不过是我们方便自己对应以及找到变量/内存地址等的手段而已。不过不管啦，反正DI里面的Scoped概念和这段解释有点点相似，是为DI提供将对象生命周期控制在自定义的范围内部的一个手段，比如我们保证http 一次请求的生命周期内，一些比如context之类的处理，我们就可以用这样的作用域概念处理，
小白同学：作用域由于考虑到不是我们自己控制，这是有使用者自定的，所以我们需要提供一些抽象接口让用户可以使用。这里呢，我们就偷懒啦，抄袭一下别人的定义
public interface IServiceScopeFactory
{
IServiceProvider CreateScopeProvider();
}
小白同学：我们来实现它
public class ServiceScopeFactory : IServiceScopeFactory
{
public IServiceProvider CreateScopeProvider()
{
return new ServiceProvider();
}
}
小白同学：大家看，多简单，完美
大神：你问过我的青龙偃月刀了吗？
小白同学（尴尬）： 哈哈，怎么可能写完了，我是开个玩笑，肯定要把服务定义给过去
public class ServiceScopeFactory : IServiceScopeFactory
{
private readonly IServiceDefintions services;
public ServiceScopeFactory(IServiceDefintions services)
{
this.services = services;
}
public IServiceProvider CreateScopeProvider()
{
return new ServiceProvider(services);
}
}
青龙偃月刀：你希望你的生命周期也和这个ServiceScopeFactory一样无处安放吗？
小白同学：为啥？我这不是实现了吗？
青龙偃月刀：ServiceScopeFactory 用户从哪里拿？
小白同学：我放进ServiceDefintions呀，
var a = new ServiceDefintions();
a.Add(new DelegateServiceDefintion(typeof(IServiceScopeFactory),typeof(ServiceScopeFactory),Lifetime.Transient, i => new ServiceScopeFactory(a)));
青龙偃月刀：hehe, ServiceProvider 由 IServiceScopeFactory 创建的都是新的吧?
小白同学：对，就是这样，才能保证是新的作用域呀
青龙偃月刀：hehe, 那新的 ServiceProvider 创建的对象也是新的吧？
小白同学：对，就是这样，新的作用域创建的对象肯定和旧的作用域创建的对象肯定不一样
青龙偃月刀：hehe, 那Singleton不是全局唯一吗?
小白同学：啥？Singleton和作用域有什么关系？我不是有字典缓存了吗？
青龙偃月刀：我真恨不得自己再把自己磨快点。
青龙偃月刀：ServiceProvider 是不是可以创建 三种不同生命周期的对象？
小白同学：对，Singleton ,Scoped, Transient
青龙偃月刀：那新的ServiceProvider创建的Singleton对象呢？
小白同学：都是从缓存字典private readonly ConcurrentDictionary<Type, object> singletonCache 里面拿呗
青龙偃月刀：。。。。。。 这个字典你放哪呢？
小白同学：我放ServiceProvider类上啊
青龙偃月刀：。。。。。。 那每一个新的ServiceProvider是不是都有一个新的缓存字典？
小白同学：吃惊.gif， 不愧是宝刀
小白同学：我换静态的 static ConcurrentDictionary<Type, object> singletonCache
青龙偃月刀：那整个程序就只有一份了啊
小白同学：对呀，就是只要一份
青龙偃月刀：那一个程序里面多个DI容器呢?
小白同学：大吃一惊.gif，还能这么玩?
青龙偃月刀：不说其他，就说你单元测试一个DI容器能测试各种场景？
小白同学：尴尬.gif 我目前只写了一个
青龙偃月刀：...............你改吧
小白同学：哦
// 小白同学：在IServiceProvider接口上添加我们需要数据字段
public interface IServiceProvider
{
Dictionary<Type, ServiceDefintion> Services {get;}
ConcurrentDictionary<Type, object> SingletonCache {get;}
}
public class ServiceProvider : IServiceProvider
{
public Dictionary<Type, ServiceDefintion> Services {get;}
public ConcurrentDictionary<Type, object> SingletonCache {get;}
// 小白同学：复用对应的缓存
public ServiceProvider(IServiceProvider provider)
{
Services = provider.Services;
SingletonCache = provider.SingletonCache;
}
}
public class ServiceScopeFactory : IServiceScopeFactory
{
private readonly IServiceProvider provider;
// 小白同学：这样我们可以直接取已有的provider
public ServiceScopeFactory(IServiceProvider provider)
{
this.provider = provider;
}
public IServiceProvider CreateScopeProvider()
{
// 小白同学：有了存在的provider，我们就能复用对应的缓存
return new ServiceProvider(provider);
}
}
小白同学：我们就可以这样注册ServiceScopeFactory了
var a = new ServiceDefintions();
a.Add(new DelegateServiceDefintion(typeof(IServiceScopeFactory),typeof(ServiceScopeFactory),Lifetime.Transient, i => new ServiceScopeFactory(i)));
青龙偃月刀：磨刀石呢？我要磨快点
小白同学：又咋了，我写的这么完美？
青龙偃月刀：你确定这样符合作用域的概念？
小白同学：怎么不符合了？SingletonCache 都只有一个了，每个ServiceProvider都是创建新的Scoped生命周期对象
青龙偃月刀：你看看你是怎么写创建新的Scoped生命周期对象的？
小白同学：这样啊
case Lifetime.Scoped:
return CreateObj(x);
青龙偃月刀：一个Scoped生命周期内，一个ServiceType对应生成对象不该唯一吗？
小白同学：为啥啊？生命周期不是用户自己控制了吗？
青龙偃月刀：一个方法的作用域内，可以声明多个同名对象吗？
小白同学：不能呀
青龙偃月刀：那你允许一个Scoped作用域内，可以生成相同ServiceType，实际不同的对象？
小白同学：他可以自己回收呗
青龙偃月刀：你让人家自己回收 ！！！？？？ 那人家为什么不用Transient，你这样和Transient有什么区别？
小白同学：你说的好有道理，我竟无言以对
小白同学：那我加缓存
public class ServiceProvider : IServiceProvider
{
private ConcurrentDictionary<Type, object> scopedCache = new ConcurrentDictionary<Type, object>();
public object CreateObj(Type serviceType)
{
case Lifetime.Scoped:
return scopedCache.GetOrAdd(serviceType, x => CreateObj(x));
}
}
小白同学：怎么样？完美吧？
青龙偃月刀：我劝你好好考虑一下，我的大刀已经饥渴难耐
小白同学：哪儿不完美？明明很beautiful
青龙偃月刀：再提示一下，用户是不是会这样用？
IServiceProvider a = IServiceScopeFactory.CreateScopeProvider();
doSomethings(a);
a.Dispose();
小白同学：对呀，可以完美应对呀
青龙偃月刀：。。。。。。。。。你的Dispose做了什么？
小白同学：emmmm 什么。。。 都没做？
青龙偃月刀：那用户Dispose什么？
小白同学：emmmm。。。。。。
小白同学：好吧，既然有问题我们再改下
public class ServiceProvider : IServiceProvider
{
private void Dispose()
{
// 小白同学：Dispose every thing
foreach (var item in SingletonCache.Union(scopedCache))
{
var disposable = item as IDisposable;
disposable?.Dispose();
}
scopedCache.Clear();
SingletonCache.Clear();
}
}
青龙偃月刀：........... 一个子作用域可以把SingletonCache Dispose 了？难道活到98岁不好吗？
小白同学：啊。。。。。活到那么久很好啊。。。。哈，我知道怎么改
public class ServiceProvider : IServiceProvider
{
public IServiceProvider Root { get; }
public ServiceProvider(IServiceProvider provider)
{
Services = provider.Services;
SingletonCache = provider.SingletonCache;
Root = provider.Root;
}
private void Dispose()
{
// 小白同学：only Root can Dispose every thing
// others can onlu disposable scopedCache
var disposables = (Root == this
? SingletonCache.Union(scopedCache)
: scopedCache)
.Where(x => x.Value != this);
foreach (var scoped in disposables)
{
var disposable = scoped.Value as IDisposable;
disposable?.Dispose();
}
scopedCache.Clear();
if (Root == this) SingletonCache.Clear();
}
}
小白同学：真完美！！！！！
青龙偃月刀：呵呵，这样也能算完美？多少没做，还有多少问题没搞？你看人家做成这样子都算差的了 - https://github.com/fs7744/Norns
