Autofac学习之三种生命周期：InstancePerLifetimeScope、SingleInstance、InstancePerDependency...

水深无声 2021-11-05 11:22 111阅读 0赞

[Autofac学习之三种生命周期：InstancePerLifetimeScope、SingleInstance、InstancePerDependency][Autofac_InstancePerLifetimeScope_SingleInstance_InstancePerDependency]

原文: [Autofac学习之三种生命周期：InstancePerLifetimeScope、SingleInstance、InstancePerDependency][Autofac_InstancePerLifetimeScope_SingleInstance_InstancePerDependency 1]

InstancePerLifetimeScope：同一个Lifetime生成的对象是同一个实例

SingleInstance：单例模式，每次调用，都会使用同一个实例化的对象；每次都用同一个对象；

InstancePerDependency：默认模式，每次调用，都会重新实例化对象；每次请求都创建一个新的对象；

验证方法实现逻辑：在类的构造函数中，给属性赋值（GUID），通过判断属性值是否一致来判断 三种生命周期的效果。

先上图看结果：

1、InstancePerLifetimeScope

![434387-20171103145534904-1240640930.png][]

2、SingleInstance

![434387-20171103145505076-522481668.png][]

3、InstancePerDependency

![434387-20171103145452154-523540336.png][]

整块代码实现如下：

using Autofac;
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Reflection;
    using System.Text;
    using System.Threading.Tasks;
    
    namespace SimpleAutofacConsole
    {
        class Program
        {
            static void Main(string[] args)
            {
                //IAnimal animal = new Tiger();
                //animal.Show("普通new()对象");
    
                var builder = new ContainerBuilder();
                var dependencyRegistrar = new DependencyRegistrar();//(IDependencyRegistrar)Activator.CreateInstance(typeof(IDependencyRegistrar));
                dependencyRegistrar.Register(builder, null);
    
                var container = builder.Build();
    
                var animalIOC = container.Resolve<IAnimal>();
                //animalIOC.Show("Autofac方式实现new()对象");
                Console.WriteLine(animalIOC.Id);
    
                var animalIOC2 = container.Resolve<IAnimal>();
                //animalIOC2.Show("第二次从容器中实例化");
                Console.WriteLine(animalIOC2.Id);
    
                Console.WriteLine("开启新的生命周期");
                ILifetimeScope inner = container.BeginLifetimeScope();
                var myClass3 = inner.Resolve<IAnimal>();
                Console.WriteLine(myClass3.Id);
                var myClass4 = inner.Resolve<IAnimal>();
                Console.WriteLine(myClass4.Id);
    
    
    
                //var animalIOC = container.Resolve<Dog>();
                //animalIOC.Show("Autofac方式实现new()对象");
    
    
    
                Console.ReadLine();
            }
        }
        public interface IAnimal
        {
            void Show(string name);
            string Id { get; set; }
        }
        public class Tiger : IAnimal
        {
            private string _Id;
            public string Id { get { return this._Id; } set { Id = this._Id; } }
            public Tiger()
            {
                _Id = Guid.NewGuid().ToString();
            }
    
            public void Show(string name)
            {
                Console.WriteLine("老虎说：" + name);
            }
        }
        public class Dog : IAnimal
        {
            public string Id { get { return Guid.NewGuid().ToString(); } set { } }
    
            public void Show(string name)
            {
                Console.WriteLine("狗狗说：" + name);
            }
        }
        public class DependencyRegistrar : IDependencyRegistrar
        {
            public int Order { get { return 0; } }
    
            public void Register(ContainerBuilder builder, ITypeFinder typeFinder)
            {
                // InstancePerLifetimeScope 同一个Lifetime生成的对象是同一个实例
                // SingleInstance 单例模式，每次调用，都会使用同一个实例化的对象；每次都用同一个对象
                // InstancePerDependency 默认模式，每次调用，都会重新实例化对象；每次请求都创建一个新的对象
                builder.RegisterType<Tiger>().As<IAnimal>().InstancePerLifetimeScope();
                //builder.RegisterType<Dog>().As<IAnimal>();//.PreserveExistingDefaults();
            }
        }
    
        public interface IDependencyRegistrar
        {
            void Register(ContainerBuilder builder,ITypeFinder typeFinder);
    
            int Order { get; }
        }
    
    
        public interface ITypeFinder
        {
            IList<Assembly> GetAssemblies();
    
            IEnumerable<Type> FindClassesOfType(Type assignTypeFrom, bool onlyConcreteClasses = true);
    
            IEnumerable<Type> FindClassesOfType(Type assignTypeFrom, IEnumerable<Assembly> assemblies, bool onlyConcreteClasses = true);
    
            IEnumerable<Type> FindClassesOfType<T>(bool onlyConcreteClasses = true);
    
            IEnumerable<Type> FindClassesOfType<T>(IEnumerable<Assembly> assemblies, bool onlyConcreteClasses = true);
        }
    }

posted on 2019-08-06 08:40 [NET未来之路][NET] 阅读( ...) 评论( ...) [编辑][Link 1] 收藏

转载于:https://www.cnblogs.com/lonelyxmas/p/11306770.html

[Autofac_InstancePerLifetimeScope_SingleInstance_InstancePerDependency]: https://www.cnblogs.com/lonelyxmas/p/11306770.html
[Autofac_InstancePerLifetimeScope_SingleInstance_InstancePerDependency 1]: https://www.cnblogs.com/daryl/p/7778190.html
[434387-20171103145534904-1240640930.png]: /images/20211105/4ce805acaacd4811b0a5995c8e4b3d5a.png
[434387-20171103145505076-522481668.png]: /images/20211105/a4e30e0f64fb480b9374e79b7db78828.png
[434387-20171103145452154-523540336.png]: /images/20211105/f3cbefc6ccfd485d8e2a419873f5fda3.png
[NET]: https://www.cnblogs.com/lonelyxmas/
[Link 1]: https://i.cnblogs.com/EditPosts.aspx?postid=11306770