漫谈.net core和Autofac中的Scoped生命周期
我们知道，.net core内置了IOC容器，通常，一个服务的生命周期有三种：Transient、Scoped、Singleton
Transient：临时性的服务，当进行服务注入时，每次都是重新创建一个新的对象实例
Scoped：范围性的服务，当在一个范围内进行服务注入时，保证使用同一个实例对象（可以理解为一个IServiceProvider中只有一个实例对象，不同的IServiceProvider中是不同的实例对象）
Singleton：单例的服务，就是在整个生命周期内，只有一个实例对象（可以理解为所有的IServiceProvider中共享一个实例对象）今天我们聊聊Scoped作用域这个生命周期。
首先，如何理解Scoped作用域？就是一个范围，还记的using的用法么？你应该在using的范围内使用相应的变量吧，超出了可能就会抛出一样，Scoped就是表示这么一个范围，所以它是一个IDisposable接口对象。举几个例子，比如我们一个请求的处理过程就是在一个Scoped作用域里面，比如我们常使用的EFCore的DbContext往往就是放在一个Scoped作用域里面。Scoped作用域就是保证在一个范围内始终保持唯一的实例，如果我们需要一个新的实例，那么我们就需要创建一个新的Scoped作用域。
.net core中的实现
既然这样，那么我们怎么区分两个作用域呢？或者换句话说，这个作用域多大呢？这就是需要一个标识，在.net core中，它是Microsoft.Extensions.DependencyInjection.IServiceScope接口，它的实现类是Microsoft.Extensions.DependencyInjection.ServiceLookup.ServiceProviderEngineScope，它是一个内部类，我们先看它大概得样子是这样的（砍掉了一些）：
internal sealed class ServiceProviderEngineScope : IServiceScope, IServiceProvider, IAsyncDisposable, IServiceScopeFactory
{
private bool _disposed;
public ServiceProviderEngineScope(ServiceProvider provider, bool isRootScope)
{
ResolvedServices = new Dictionary<ServiceCacheKey, object>();
RootProvider = provider;
IsRootScope = isRootScope;
}
internal Dictionary<ServiceCacheKey, object> ResolvedServices { get; }
public bool IsRootScope { get; }
internal ServiceProvider RootProvider { get; }
public object GetService(Type serviceType)
{
if (_disposed)
{
ThrowHelper.ThrowObjectDisposedException();
}
return RootProvider.GetService(serviceType, this);
}
public IServiceProvider ServiceProvider => this;
public IServiceScope CreateScope() => RootProvider.CreateScope();
} 可以看到，ServiceProviderEngineScope实现了IServiceScope, IServiceProvider, IAsyncDisposable, IServiceScopeFactory 几个接口（一个类四用，这个作者偷懒了，呵呵）：
IServiceScope，表示他是一个Scoped范围
IServiceProvider，表示它是一个Scoped范围的容器接口
IAsyncDisposable，表示他是一个异步释放的对象
IServiceScopeFactory，表示他是一个Scoped范围工厂 我们现在梳理一下Scoped作用域的使用流程，首先我们从容器中得到IServiceScopeFactory 的实现（其实就是ServiceProviderEngineScope，而且是Singleton），然后我们通过IServiceScopeFactory的CreateScope方法创建一个IServiceScope作用域对象（其实也是ServiceProviderEngineScope），接着调用IServiceScope作用域的ServiceProvider属性得到一个新容器（其实就是IServiceScope作用域自身，也就是ServiceProviderEngineScope），最后当我们调用ServiceProvider属性的GetService方法时，其实就是调用IServiceScope的GetService方法（也就是ServiceProviderEngineScope的GetService方法），最终由RootProvider根容器调用它自己的GetService方法来创建实例，注意，这个时候它不仅传了类型，还传入了当前IServiceScope对象作为区分不同Scoped作用域的一个标识，ServiceProviderEngineScope构造函数中传进来的的ServiceProvider ，其实就是根容器，也就是说，实际上所有的服务最终都是由根容器创建的。
在实际开发中，我们可以通过几种方式来创建一个IServiceScope的作用域，但最终都是通过IServiceScopeFactory 接口来创建作用域的，比如通过IServiceProvider的CreateScope拓展方法:
public static IServiceScope CreateScope(this IServiceProvider provider)
{
return provider.GetRequiredService<IServiceScopeFactory>().CreateScope();
}
public static AsyncServiceScope CreateAsyncScope(this IServiceProvider provider)
{
return new AsyncServiceScope(provider.CreateScope());
} CreateAsyncScope创建了一个异步的作用域，允许我们在代码中使用异步的方式来释放，但是最终，无论是CreateScope还是CreateAsyncScope，最终都是通过IServiceScopeFactory 接口来创建作用域的。
注意：这个时候，你可能会想，通过CreateScope拓展方法创建作用域于IServiceScopeFactory 接口来创建作用域是等价的，但是其实不然，这个等价是有前提的，因为IServiceScopeFactory 是一个单例，因此它每次都能创建一个新的作用域，但是使用CreateScope拓展方法创建的作用域会优先获取IServiceScopeFactory 接口实现，再来使用IServiceScopeFactory 创建新的作用域，这就有问题了，在ServiceProviderEngineScope源码中可以看到，如果当前的ServiceProviderEngineScope对象已经释放了，它的GetService方法将会抛出ObjectDisposedException异常，这也是很多同学在使用作用域是碰到最多的情况。怎么避免这种问题呢？前面已经提示了，因为IServiceScopeFactory 是单例的，所以我们只需要在作用域有效期内创建即可，后续可以随便使用来创建新的作用域，不管创建这个IServiceScopeFactory 的容器是否已经被释放（即作用域是否已释放）。
还有这里记一点，.net core原生的作用域是没有作用域树的概念的，也就是说，它的每个作用域都是一样的，他们均由根容器创建，一个父作用域创建了一个子作用域，如果父作用域释放了，并不影响子作用域的使用！
Autofac在.net core中的集成
其实Autofac的生命周期很多，连Scoped作用域还分好几种，以后有机会可以再写写，这里我以官方的Autofac.Extensions.DependencyInjection库集成到.net core中使用的方式，来叙述它与原生.net core中Scoped作用域的区别。
首先，可以使用Nuget按照Autofac.Extensions.DependencyInjection库，但是不同版本.net core的集成方式可能不一样，我这里使用.net 6，只需要这么用就可以了：
var builder = WebApplication.CreateBuilder(args);
//替换原生容器
builder.Host.UseServiceProviderFactory(new AutofacServiceProviderFactory());上述代码使用后，原生容器的一些服务就会被替换掉了：
IServiceProvider：使用AutofacServiceProvider对象来实现
IServiceScopeFactory：使用AutofacServiceScopeFactory对象来实现，注意，这个时候，它就不是单例了，而是临时的
IServiceScope：使用AutofacServiceScope对象来实现 public static void Populate(this ContainerBuilder builder,IEnumerable<ServiceDescriptor> descriptors,object lifetimeScopeTagForSingletons)
{
if (descriptors == null)
{
throw new ArgumentNullException(nameof(descriptors));
}
var serviceProviderRegistration = builder.RegisterType<AutofacServiceProvider>()
.As<IServiceProvider>()
.ExternallyOwned();
#if NET6_0_OR_GREATER
// Add the additional registration if needed.
serviceProviderRegistration.As<IServiceProviderIsService>();
#endif
builder.RegisterType<AutofacServiceScopeFactory>().As<IServiceScopeFactory>();
Register(builder, descriptors, lifetimeScopeTagForSingletons);
} 我们在注入IServiceProvider时，就会使用AutofacServiceProvider对象，它会传入一个Autofac的ILifetimeScope接口，调用AutofacServiceProvider的GetService方法本质上就是调用ILifetimeScope的对应的方法，这样，就与原生的方案对齐了。
不过这里要说的是Scoped作用域的集成使用，首先，使用流程上与原生的方式是一样的，但是Autofac的容器是一个作用域树的结构，它的根容器是IContainer接口（其实也是一个ILifetimeScope接口，实现类是Autofac.Core.Container），根容器传进的其它ILifetimeScope 都是子容器（实现类是Autofac.Core.Lifetime.LifetimeScope），它与父容器密切相关，当你从一个ILifetimeScope容器中获取服务时，它会检查当前容器以及所有的父、祖父等容器是否有效，也就是有没有释放，如果已释放，那么子容器就不可以使用了，这点与.net core原生的设计是不一样的。
public class LifetimeScope : Disposable, ISharingLifetimeScope, IServiceProvider
{
...
public ILifetimeScope BeginLifetimeScope(object tag)
{
CheckNotDisposed();
CheckTagIsUnique(tag);
var scope = new LifetimeScope(ComponentRegistry, this, tag);
RaiseBeginning(scope);
return scope;
}
private void CheckNotDisposed()
{
if (IsTreeDisposed())
{
throw new ObjectDisposedException(LifetimeScopeResources.ScopeIsDisposed, innerException: null);
}
}
private bool IsTreeDisposed()
{
return IsDisposed || (_parentScope?.IsTreeDisposed() ?? false);
}
}这样，可能就有问题了，比如：
public void Test(IServiceProvider serviceProvider)
{
var parentScope = serviceProvider.CreateScope();
var childScope = parentScope.ServiceProvider.CreateScope();
var serviceScopeFactory = childScope.ServiceProvider.GetRequiredService<IServiceScopeFactory>();
parentScope.Dispose();
//如果是Autofac，这里会报错，如果.net core原生容器则不会
var service = childScope.ServiceProvider.GetService<MyService>();
//哪怕是提前获取了服务，如果是Autofac，这里也会报错
var newScope = serviceScopeFactory.CreateScope();
}那么怎么解决这个问题？要么在开发的时候注意一下，不要随意释放容器，要么我们就从根容器来创建Scoped作用域，为此，我们只需要获取到根容器即可。
获取根容器的方法有好几个，最简单一个就是使用全局变量保存起来，.net core在启动过程中，在添加管道中间件时（也就是各种app.UserXXX），内部有个容器，它就是就是根容器，比如（我这里是.net6）:
var builder = WebApplication.CreateBuilder(args);
//替换原生容器
builder.Host.UseServiceProviderFactory(new AutofacServiceProviderFactory());
//获取ApplicationBuilder
var app = builder.Build();
//保存到静态变量中去，以后就可以使用Providers.Root得到根容器了，这个办法是通用的
Providers.SetRoot(app.Services);
class Providers
{
static IServiceProvider root;
public static IServiceProvider Root => root;
public static void SetRoot(IServiceProvider serviceProvider)
{
root = serviceProvider;
}
}但是个人建议，在实际开发过程中，我们应该尽量避免使用根容器，如果确实需要，我们应该使用根容器来创建作用域，再来实现我们的业务，使用完记得释放作用域。
除此之外，我们还有一个办法，不就是要从根节点获取一个新的作用域的，干脆通过拓展方法来保证我们的作用域是从根容器创建的就行了，比如：
public static class ServiceProviderExtensions
{
public static IServiceScope CreateRootScope(this IServiceProvider serviceProvider)
{
IServiceScopeFactory serviceScopeFactory;
//如果是Autofac
if (serviceProvider is AutofacServiceProvider autofacServiceProvider)
{
if (autofacServiceProvider.LifetimeScope is Autofac.Core.Lifetime.LifetimeScope lifetimeScope)
{
serviceScopeFactory = lifetimeScope.RootLifetimeScope.Resolve<IServiceScopeFactory>();
}
else
{
//从根节点获取就可以了
serviceScopeFactory = autofacServiceProvider.GetRequiredService<IServiceScopeFactory>();
}
}
else
{
serviceScopeFactory = serviceProvider.GetRequiredService<IServiceScopeFactory>();
}
//否则直接创建
return serviceScopeFactory.CreateScope();
}
}所以，开发过程中，我们需要注意这些细节。
结语
本文源于一次bug的解决，过程中总是出现服务被释放的问题，就是在写一些定时任务的时候，没控制好作用域，导致父作用域被释放了，找了很久，最终定位到就是作用域的用法错误，算是积累了一次经验吧，这里我把它写出来，记录原生容器与Autofac的差异，后续肯定还有同学碰到的。
.net core的容器不是很好用，所以一般我比较喜欢集成Autofac，但是因为兼容性的问题，过程中确实碰到了很多问题，这里说的就是其中一个，再比如之前提到的命名服务的问题，希望.net core的生态越来越好吧。至于Autofac，确实是非常优秀的.net库，后面看下有时间在写它的介绍，用法确实非常丰富，
