使用 .NET 4.0 中的Lazy<T> 实现延迟初始化

延迟初始化就是将对象的初始化延迟到第一次使用该对象时。延迟初始化是我们在写程序时经常会遇到的情形，例如创建某一对象时需要花费很大的开销，而这一对象在系统的运行过程中不一定会用到，这时就可以使用延迟初始化，在第一次使用该对象时再对其进行初始化，使用延迟初始化可以提高程序的效率，使程序占用更少的内存。在 .NET 4.0 之前要实现延迟初始化，需要我们自己动手编写具体的实现方式（关于延迟初始化的实现方式，可以参看这个 http://msdn.microsoft.com/en-us/vcsharp/bb870976.aspx .NET 4.0 的 Lazy<T> 的实现方式与此相似）。在 .NET 4.0 中提供了一个泛型类 System.Lazy<T> 可以帮助我们实现延迟初始化。

首先我们来看下面的代码：

01
class Program

02
   {

03
       static void Main(string[] args)

04
       {

05
           Lazy<Customer> customer = new Lazy<Customer>();

06
           if (!customer.IsValueCreated)

07
               Console.WriteLine("Customer 尚未初始化。");

08
 
09
           Console.WriteLine("客户姓名是：{0}", customer.Value.Name);

10
 
11
           if (customer.IsValueCreated)

12
               Console.WriteLine("Customer 已经初始化。");

13
 
14
           Console.ReadKey();

15
       }

16
   }

17
 
18
   public class Customer

19
   {

20
       public Customer()

21
       {

22
           Name = "张三";

23
           Console.WriteLine("调用 Customer 的构造函数。");

24
       }

25
 
26
       public string Name { get; set; }

27
 
28
       public List<Order> Orders { get; set; }

29
   }

30
 
31
   public class Order

32
   {

33
       public string ID { get; set; }

34
   }

下面是输出结果:

Customer 尚未初始化。
调用 Customer 的构造函数。
客户姓名是：张三
Customer 已经初始化。

当 customer.Value 被调用时 Customer 才被初始化。只读属性 Value 返回延迟初始化的对象，布尔属性 IsValueCreated 标识延迟初始化的对象是否已经初始化。在上面的示例代码中是在 Customer 类的构造函数中设置的 Name 属性的值，我们可以使用 Lazy<T> 的重载函数 Lazy< T> (Func< T> ) 传入一个带返回值的委托来设置延迟初始化对象的属性值。

1
Lazy<Customer> customer1 = new Lazy<Customer>(

2
    () =>

3
    {

4
        return new Customer { Name = "李四" };

5
    });

以下是输出结果：

Customer 尚未初始化。
调用 Customer 的构造函数。
客户姓名是：李四
Customer 已经初始化。

可以看到 customer1 的 Value 属性使用的是通过委托传入的参数初始化的。

要实现公共属性的延迟初始化，将属性对应的字段定义为 Lazy<T>，然后通过 get 访问器返回字段的 Value 属性。

01
public class Customer

02
    {

03
        public Customer()

04
        {

05
            Name = "张三";

06
            Console.WriteLine("调用 Customer 的构造函数。");

07
 
08
            _orders = new Lazy<List<Order>>(() =>

09
                {

10
                    // 初始化

11
                    return new List<Order>

12
                    {

13
                        new Order { ID = "1" },

14
                        new Order { ID = "2" },

15
                        new Order { ID = "3" }

16
                    };

17
                }

18
            );

19
        }

20
 
21
        public string Name { get; set; }

22
 
23
        private Lazy<List<Order>> _orders;

24
        public List<Order> Orders

25
        {

26
            get

27
            {

28
                return _orders.Value; // 将在第一次访问时创建

29
            }

30
        }

31
    }

32
 
33
    public class Order

34
    {

35
        public string ID { get; set; }

36
    }

Lazy<T> 对象初始化默认是线程安全的，在多线程环境下，第一个访问 Lazy<T> 对象的 Value 属性的线程将初始化 Lazy<T> 对象，以后访问的线程都将使用第一次初始化的数据。

参考：http://msdn.microsoft.com/en-us/library/dd997286.aspx