好得很程序员自学网

<tfoot draggable='sEl'></tfoot>

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

使用 .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

作者: Leo_wl

    

出处: http://www.cnblogs.com/Leo_wl/

    

本文版权归作者和博客园共有,欢迎转载,但未经作者同意必须保留此段声明,且在文章页面明显位置给出原文连接,否则保留追究法律责任的权利。

版权信息

查看更多关于使用 .NET 4.0 中的Lazy<T> 实现延迟初始化的详细内容...

  阅读:54次