AutoFac 生命周期管理

86 阅读 0 评论 57 点赞

我是靠谱客的博主帅气哈密瓜，最近开发中收集的这篇文章主要介绍AutoFac 生命周期管理，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

 public void ConfigureContainer(ContainerBuilder containerBuilder)
        {
            #region 指定控制器由AutoFac 进行实例获取
            var assembly = this.GetType().GetTypeInfo().Assembly;
            var builder = new ContainerBuilder();

            //新建Mvc管理程序集填入当前程序集 
            var manager = new ApplicationPartManager();
            manager.ApplicationParts.Add(new AssemblyPart(assembly));
            manager.FeatureProviders.Add(new ControllerFeatureProvider());
            var feature = new ControllerFeature();
            manager.PopulateFeature(feature);

            //创建单例并且允许属性注入
            builder.RegisterType<ApplicationPartManager>().AsSelf().SingleInstance();
            builder.RegisterTypes(feature.Controllers.Select(t => t.AsType()).ToArray()).PropertiesAutowired();
            #endregion


            
            //瞬时生命周期 每次获取实例不一样
            containerBuilder.RegisterType<ServiceA>().As<IServiceA>().InstancePerDependency();
            //单例 整个容器获取实例都是同一个
            containerBuilder.RegisterType<ServiceB>().As<IServiceB>().SingleInstance();
          
            //作用域生命周期 只有在相同作用域下获取到的服务实例才相同
            containerBuilder.RegisterType<ServiceC>().As<IServiceC>().InstancePerLifetimeScope();
            //匹配作用域生命周期 精确到某个作用域
            containerBuilder.RegisterType<ServiceD>().As<IServiceD>().InstancePerMatchingLifetimeScope("MyScope");
            //某个请求生命周期 不同请求获取的服务实例不一样
            containerBuilder.RegisterType<ServiceE>().As<IServiceE>().InstancePerRequest();
            // 隐式关联类型创建嵌套的生命周期范围

            containerBuilder.RegisterType<ServiceG>().InstancePerOwned<IServiceF>();
            containerBuilder.RegisterType<ServiceF>().Keyed<IServiceF>("ServiceF1");


            var container = containerBuilder.Build();
            var serviceA1 = container.Resolve<IServiceA>();
            var serviceA2 = container.Resolve<IServiceA>();
            Console.WriteLine("ServiceA1 和 serviceA2 是否相同" +ReferenceEquals(serviceA1,serviceA2));

            var serviceB1 = container.Resolve<IServiceB>();
            var serviceB2 = container.Resolve<IServiceB>();
            Console.WriteLine("ServiceB1 和 serviceB2 是否相同" + ReferenceEquals(serviceB1, serviceB2));

            using var scope1 = container.BeginLifetimeScope("scope1");
            var serviceC1 = scope1.Resolve<IServiceC>();
            var serviceC2 = scope1.Resolve<IServiceC>();
            Console.WriteLine("ServiceC1 和 serviceC2 是否相同" + ReferenceEquals(serviceC1, serviceC2));

            using var scope2 = container.BeginLifetimeScope("scope2");
            var serviceC3 = scope2.Resolve<IServiceC>();
            Console.WriteLine("ServiceC1 和 serviceC3 是否相同" + ReferenceEquals(serviceC1, serviceC3));
            scope1.Dispose();
            scope2.Dispose();

            using var myScope = container.BeginLifetimeScope("MyScope");
            var serviceD1 = myScope.Resolve<IServiceD>();
            var serviceD2 = myScope.Resolve<IServiceD>();
            Console.WriteLine("ServiceD1 和 serviceD2 是否相同" + ReferenceEquals(serviceD1, serviceD2));

            var serviceF1 = myScope.ResolveKeyed<Owned<IServiceF>>("ServiceF1");
            serviceF1.Value.Call();
            serviceF1.Value.Call2();
        }

InstancePerDependency() 瞬时生命周期每次获取实例不一样
SingleInstance() 单例整个容器获取实例都是同一个
InstancePerLifetimeScope() 作用域生命周期只有在相同作用域下获取到的服务实例才相同
InstancePerMatchingLifetimeScope("MyScope") 匹配作用域生命周期精确到某个作用域
InstancePerRequest() 某个请求生命周期不同请求获取的服务实例不一样

以上5点就不细说了，有很多详细的教程和解读了。关键来看最后一个，主要代码抽取出来

{
            containerBuilder.RegisterType<ServiceG>().InstancePerOwned<IServiceF>();
            containerBuilder.RegisterType<ServiceF>().Keyed<IServiceF>("ServiceF1");
            var serviceF1 = myScope.ResolveKeyed<Owned<IServiceF>>("ServiceF1");
            serviceF1.Value.Call();
            serviceF1.Value.Call2();
}
{
    public class ServiceF : IServiceF
    {
        public ServiceF(ServiceG serviceG)
        {
            ServiceG = serviceG;
            Console.WriteLine(this.GetType().Name+"已经被初始化");
        }

        public ServiceG ServiceG { get;}

        public void Call()
        {
            Console.WriteLine(this.GetType().Name + "Call");
        }

        public void Call2()
        {
            ServiceG.Call();
        }
    }
}
{
    public class ServiceG:IServiceG
    {
        public void Call()
        {
            Console.WriteLine(this.GetType().Name + "Call");
        }

        public ServiceG()
        {
            Console.WriteLine(this.GetType().Name + "已经被初始化");
        }
    }
}

运行结果如下

调用顺序是ServiceG先被初始化，然后是初始化ServiceF。ServiceG和ServiceF的生命周期应该是相同的。

个人理解如下

containerBuilder.RegisterType<ServiceG>().InstancePerOwned<IServiceF>(); 这行代码将ServiceG的生命周期限定在了ServiceF的生命周期之下，如果提前释放ServiceF的的生命周期，那么ServiceG中的服务应该也无法使用。

但目前关于InstancePerOwned的文档并不多，而且很模糊。如果理解有误，望大佬指教一下。