• 使用 .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
  • 相关阅读:
    centos7安装nginx
    linux经常使用的命令
    linux 安装 VNC
    linux配置yum源
    docker服务器、以及容器设置自动启动
    docker初步学习以及常用命令
    Docker命令详解（run篇）
    Linux scp命令
    Linux常用命令学习31个
    Linux下解压tar.xz文件
  • 原文地址：https://www.cnblogs.com/Leo_wl/p/2041690.html
Copyright © 2020-2023  润新知