依赖注入 生命周期

.net core里面

依赖注入生命 大部分常用的就三总 

• Scoped（作用域 也可以说是线程单例 

        在同一个线程里是单例的 

• Transient（瞬时）

  每一次请求都是一个全新的实例 适用于轻量级无状态服务

• Singleton（单例模式）

应用启动时候被创建一次 后面都是使用第一次创建的实例

• 
  

我用 Unity做了一个例子出来

public interface IReady
    {
        string Getcontent();
    }

    public class Book : IReady
    {
        public string Getcontent()
        {
            return "Say Book";
        }
    }

    public class Paper : IReady
    {
        public string Getcontent()
        {
            return "Say Paper";
        }
    }

    public class Father
    {
        public IReady Ready { get; set; }

        public Father(IReady ready)
        {
            Ready = ready;
        }

        public void Action()
        {
            Console.WriteLine("ACtion");
            Console.WriteLine(Ready.Getcontent());
        }
    }

瞬时

 static void Main(string[] args)
 {
  var container = new UnityContainer();
                container.RegisterType<IReady, Book>();

                //Unity 瞬时
                container.RegisterType<Father>();
                var father1 = container.Resolve<Father>();
                var father2 = container.Resolve<Father>();
                ////father1.Action();

                Console.WriteLine($" father1 = father1 : {ReferenceEquals(father1, father2)}");
 }

对比出的结果是 false Unity里面的默认注册生命周期是瞬时

单例

//Unity单例
                container.RegisterSingleton<Father>();
                var father1 = container.Resolve<Father>();
                var father2 = container.Resolve<Father>();
                Console.WriteLine($"father1 = father2 :{ReferenceEquals(father1,father2)}");

结果是 true 证明 father2和father1使用的是一个实例

线程单例（作用域）

 var container = new UnityContainer();
                container.RegisterType<IReady, Book>();
                container.RegisterType<Father>(TypeLifetime.PerThread);
                Father father1 = null;
                Father father2 = null;
                Father father3 = null;

                var task1 = Task.Run(() =>
                {
                    father1 = container.Resolve<Father>();
                    Console.WriteLine($"当前线程的Id={Thread.GetCurrentProcessorId()}");

                });
                var task2 = Task.Run(() =>
                {
                    father2 = container.Resolve<Father>();
                    father3 = container.Resolve<Father>();
                    Console.WriteLine($"当前的线程Id={Thread.GetCurrentProcessorId()}");

                });

                task1.Wait();
                task2.Wait();

                Console.WriteLine($"father1 = father2 :{ReferenceEquals(father1,father2)}");
                Console.WriteLine($"father2 = father3 :{ReferenceEquals(father3, father2)}");

结果分别是 false 和true 证明 一个线程里面是使用的是一个实例 分开了 使用的就是不同的实例