基礎(chǔ)才是重中之重~延遲初始化

 回到目錄

概念：一個(gè)對(duì)象的延遲初始化（也稱延遲實(shí)例化）意味著該對(duì)象的創(chuàng)建將會(huì)延遲至第一次使用該對(duì)象時(shí)。 延遲初始化主要用于提高性能，避免浪費(fèi)計(jì)算，并減少程序內(nèi)存要求。

以下是最常見的方案：

• 有一個(gè)對(duì)象的創(chuàng)建開銷很大時(shí)，應(yīng)用程序可能不會(huì)使用它。 例如，假定您在內(nèi)存中有一個(gè) Customer 對(duì)象，該對(duì)象的 Orders 屬性返回一個(gè) Orders 對(duì)象。 初始化 Orders 對(duì)象可能需要?jiǎng)?chuàng)建 Orders 對(duì)象的一個(gè)大數(shù)組（Orders[]），并可能需要數(shù)據(jù)庫連接。 如果用戶從不訪問 Orders 屬性，則沒有理由使用系統(tǒng)內(nèi)存或計(jì)算周期來創(chuàng)建 Orders 對(duì)象。 通過使用 Lazy<Orders> 將 Orders 對(duì)象聲明為延遲初始化，可以避免在不使用該對(duì)象的情況下浪費(fèi)系統(tǒng)資源。

• 有一個(gè)對(duì)象的創(chuàng)建開銷很大，您想要將創(chuàng)建它的時(shí)間延遲到完成其他開銷大的操作之后。 例如，假定您的應(yīng)用程序在啟動(dòng)時(shí)加載若干個(gè)對(duì)象實(shí)例，但只有一些對(duì)象實(shí)例需要立即執(zhí)行。 通過將不必要的對(duì)象的初始化延遲到已創(chuàng)建必要的對(duì)象之后，可以提高應(yīng)用程序的啟動(dòng)性能。

  盡管您可以編寫自己的代碼來執(zhí)行遲緩初始化，但我們建議改用 System..::.Lazy<(Of <(T>)>) 類。 Lazy<(Of <(T>)>) 支持線程安全(在一個(gè)線程中創(chuàng)建實(shí)例后，對(duì)其它線也是共享的)，并提供一致的異常傳播策略。

  基本語法：
  

  1 Lazy<Orders> Orders=new Lazy<Orders>();

  另外，還可以在 Lazy<(Of <(T>)>) 構(gòu)造函數(shù)中傳遞一個(gè)委托，用于在創(chuàng)建時(shí)調(diào)用包裝類的特定構(gòu)造函數(shù)重載，并執(zhí)行所需的任何其他初始化步驟，如以下示例中所示。

  1 Lazy<Orders> _orders = new Lazy<Orders>(() => new Orders(OrderSorted.CreateDate)); //可以重載指定的構(gòu)造函數(shù)，如用來實(shí)現(xiàn)一種排序規(guī)則

  在創(chuàng)建 Lazy 對(duì)象之后，在第一次訪問 Lazy<(Of <(T>)>) 實(shí)例的 Value 屬性之前，將不會(huì)創(chuàng)建 Orders 的實(shí)例。 在第一次訪問包裝類型時(shí)，將會(huì)創(chuàng)建并返回該包裝類型，并將其存儲(chǔ)起來以備任何將來的訪問。

  1 // 當(dāng)滿足一種條件時(shí)，再去創(chuàng)建orders對(duì)象
  2 if (displayOrders == true)
  3 {
  4     DisplayOrders(_orders.Value.OrderData);
  5 }
  6 else
  7 {
  8     // Don't waste resources getting order data.
  9 }

  線程安全初始化

  默認(rèn)情況下，Lazy<(Of <(T>)>) 對(duì)象是線程安全的。 這意味著如果構(gòu)造函數(shù)未指定線程安全性的類型，它創(chuàng)建的 Lazy<(Of <(T>)>) 對(duì)象都是線程安全的。 在多線程方案中，要訪問線程安全的 Lazy<(Of <(T>)>) 對(duì)象的 Value 屬性的第一個(gè)線程將為所有線程上的所有后續(xù)訪問初始化該對(duì)象，并且所有線程都共享相同數(shù)據(jù)。 因此，由哪個(gè)線程初始化對(duì)象并不重要，爭用條件將是良性的。

   1 // Initialize the integer to the managed thread id of the 
   2 // first thread that accesses the Value property.
   3 Lazy<int> number = new Lazy<int>(() => 
   4      Thread.CurrentThread.ManagedThreadId);
   5 
   6 Thread t1 = new Thread(() => 
   7     Console.WriteLine("number on t1 = {0} ThreadID = {1}",
   8                       number.Value, Thread.CurrentThread.ManagedThreadId));
   9 t1.Start();
  10 
  11 Thread t2 = new Thread(() => 
  12     Console.WriteLine("number on t2 = {0} ThreadID = {1}",
  13                       number.Value, Thread.CurrentThread.ManagedThreadId));
  14 t2.Start();
  15 
  16 Thread t3 = new Thread(() => 
  17     Console.WriteLine("number on t3 = {0} ThreadID = {1}", number.Value,
  18                       Thread.CurrentThread.ManagedThreadId));
  19 t3.Start();
  20 
  21 // Ensure that thread IDs are not recycled if the 
  22 // first thread completes before the last one starts.
  23 t1.Join();
  24 t2.Join();
  25 t3.Join();
  26 
  27 /* Sample Output:
  28     number on t1 = 11 ThreadID = 11
  29     number on t3 = 11 ThreadID = 13
  30     number on t2 = 11 ThreadID = 12
  31     Press any key to exit.
  32 */

  實(shí)現(xiàn)延遲初始化屬性

  若要通過使用延遲初始化來實(shí)現(xiàn)一個(gè)公共屬性，請(qǐng)將該屬性的支持字段定義為 Lazy<(Of <(T>)>) 對(duì)象，并從該屬性的 get 訪問器返回 Value 屬性。

   1 class Customer
   2 {
   3     private Lazy<Orders> _orders;
   4     public string CustomerID {get; private set;}
   5     public Customer(string id)
   6     {
   7         CustomerID = id;
   8         _orders = new Lazy<Orders>(() =>
   9         {
  10             // You can specify any additonal 
  11             // initialization steps here(這個(gè)Orders不會(huì)應(yīng)該Customer的實(shí)例化，而被實(shí)例化，它只會(huì)在使時(shí)，才會(huì)被實(shí)例化)
  12             return new Orders(this.CustomerID);
  13         });
  14     }
  15 
  16     public Orders MyOrders
  17     {
  18         get
  19         {
  20             // Orders is created on first access here.
  21             return _orders.Value;
  22         }
  23     }
  24 }

  延時(shí)實(shí)例化，在大對(duì)象時(shí)使用比較多，使用Lazy<(Of <(T>)>)我們還可以實(shí)現(xiàn)一種泛型的單例基類，看代碼：

   1  /// <summary>
   2     /// 泛型單例基類
   3     /// </summary>
   4     public abstract class Singleton<TEntity> where TEntity : class
   5     {
   6         private static readonly Lazy<TEntity> _instance
   7           = new Lazy<TEntity>(() =>
   8           {
   9               var ctors = typeof(TEntity).GetConstructors(
  10                   BindingFlags.Instance
  11                   | BindingFlags.NonPublic
  12                   | BindingFlags.Public);
  13               if (ctors.Count() != 1)
  14                   throw new InvalidOperationException(String.Format("Type {0} must have exactly one constructor.", typeof(TEntity)));
  15               var ctor = ctors.SingleOrDefault(c => c.GetParameters().Count() == 0 && c.IsPrivate);
  16               if (ctor == null)
  17                   throw new InvalidOperationException(String.Format("The constructor for {0} must be private and take no parameters.", typeof(TEntity)));
  18               return (TEntity)ctor.Invoke(null);
  19           });
  20 
  21         public static TEntity Instance
  22         {
  23             get { return _instance.Value; }
  24         }
  25     }

   

    回到目錄

  參考 文獻(xiàn)：
  

  http://technet.microsoft.com/zh-cn/magazine/dd997286%28VS.95%29.aspx

  http://www.fascinatedwithsoftware.com/blog/post/2011/07/13/A-Generic-Singleton-Class.aspx

   

  返回目錄  基礎(chǔ)才是重中之重系列~目錄(永久更新中)