延迟实例化 Lazy<T>

之前写的设计模式 单例模式中，推荐了使用Lazy<T>来达到线程安全和减少系统资源消耗的作用。

作用及优点：

创建某一个对象需要很大的消耗，而这个对象在运行过程中又不一定用到，为了避免每次运行都创建该对象，这时候延迟初始化（也叫延迟实例化）就出场了。

示例代码1：（不使用参数Lazy<T>()）

 1 class Program
 2     {
 3         static void Main(string[] args)
 4         {
 5             Lazy<Teacher> lazy = new Lazy<Teacher>();//延迟实例化
 6             Student s = new Student();//实例化
 7             Console.WriteLine(lazy.Value.Name);
 8             Console.WriteLine(s.Name);
 9         }
10     }
11     class Student
12     {
13         public string Name => "StudentA";
14         public Student()
15         {
16             Console.WriteLine("Student");
17         }
18     }
19     class Teacher
20     {
21         public string Name => "TeacherA";
22         public Teacher()
23         {
24             Console.WriteLine("Teacher");
25         }
26     }

运行结果：

从中我们很容易的看出来了Teacher类实例化被延迟了。观众朋友们可以试一试吧两个打印换下位置。最终可以发现只有在延迟实例化的对象被使用时才会真正实例化。(没有参数实例化类时，调用的是默认构造函数)

示例代码2：（使用Func<T>参数Lazy<T>(Func<T>)）

 1 class Program
 2     {
 3         static void Main(string[] args)
 4         {
 5             string a = "lazy";
 6             Lazy<Student> s = new Lazy<Student>(()=>new Student(a));//指定构造函数（方便区别选择了有参构造函数）
 7             Console.WriteLine(s.Value.Name);
 8         }
 9     }
10     class Student
11     {
12         public string Name => "StudentA";
13         public Student()
14         {
15             Console.WriteLine("Student");
16         }
17         public Student(string a)
18         {
19             Console.WriteLine(a);
20         }
21     }

运行结果：

 

 

从操作结果中可以看出，延迟实例化调用了了指定的构造函数。Func<T>是一个带返回值的委托。

参考：

同时我还发现这样一个问题：我之后会看看这个应该怎么描述 如果有知道的大牛希望能不吝赐教。

1             string a = "lazy";
2             Lazy<Student> s = new Lazy<Student>(()=>new 
3             Student(a));
4             a = "1234";//修改a
5             Console.WriteLine(s.Value.Name);
6             /*输出结果：
7             /*1234
8             /*StudentA

感觉合情合理 但是不清楚应该怎么描述。

最后附上：Lazy官方介绍地址

 

转载于:https://www.cnblogs.com/Jeese/p/7443621.html