Thực hiện Lazy <T> cho .NET 3.5

Question

.NET 4.0 có lớp tiện ích tốt được gọi là System.Lazy làm khởi tạo đối tượng lười. Tôi muốn sử dụng lớp này cho một dự án 3.5. Một lần tôi nhìn thấy một thực hiện ở đâu đó trong một câu trả lời stackoverflow nhưng tôi không thể tìm thấy nó nữa. Có ai có thực hiện thay thế Lazy? Nó không cần tất cả các tính năng an toàn của phiên bản 4.0 của khung công tác.

Cập nhật:

Answers chứa a thread không an toàn và một phiên bản đề an toàn.

Answer 1

Đây là một thực hiện mà tôi sử dụng.

/// <summary> 
/// Provides support for lazy initialization. 
/// </summary> 
/// <typeparam name="T">Specifies the type of object that is being lazily initialized.</typeparam> 
public sealed class Lazy<T> 
{ 
    private readonly object padlock = new object(); 
    private readonly Func<T> createValue; 
    private bool isValueCreated; 
    private T value; 

    /// <summary> 
    /// Gets the lazily initialized value of the current Lazy{T} instance. 
    /// </summary> 
    public T Value 
    { 
     get 
     { 
      if (!isValueCreated) 
      { 
       lock (padlock) 
       { 
        if (!isValueCreated) 
        { 
         value = createValue(); 
         isValueCreated = true; 
        } 
       } 
      } 
      return value; 
     } 
    } 

    /// <summary> 
    /// Gets a value that indicates whether a value has been created for this Lazy{T} instance. 
    /// </summary> 
    public bool IsValueCreated 
    { 
     get 
     { 
      lock (padlock) 
      { 
       return isValueCreated; 
      } 
     } 
    } 


    /// <summary> 
    /// Initializes a new instance of the Lazy{T} class. 
    /// </summary> 
    /// <param name="createValue">The delegate that produces the value when it is needed.</param> 
    public Lazy(Func<T> createValue) 
    { 
     if (createValue == null) throw new ArgumentNullException("createValue"); 

     this.createValue = createValue; 
    } 


    /// <summary> 
    /// Creates and returns a string representation of the Lazy{T}.Value. 
    /// </summary> 
    /// <returns>The string representation of the Lazy{T}.Value property.</returns> 
    public override string ToString() 
    { 
     return Value.ToString(); 
    } 
} 

Answer 2

Nếu bạn không cần an toàn chỉ, bạn có thể dễ dàng đặt cùng với phương pháp nhà máy. Tôi sử dụng một trong rất tương tự như sau:

public class Lazy<T> 
{ 
    private readonly Func<T> initializer; 
    private bool isValueCreated; 
    private T value; 

    public Lazy(Func<T> initializer) 
    { 
     if (initializer == null) 
      throw new ArgumentNullException("initializer"); 
     this.initializer = initializer; 
    } 

    public bool IsValueCreated 
    { 
     get { return isValueCreated; } 
    } 

    public T Value 
    { 
     get 
     { 
      if (!isValueCreated) 
      { 
       value = initializer(); 
       isValueCreated = true; 
      } 
      return value; 
     } 
    } 
} 

Answer 3

Một điều khá đơn giản hóa phiên bản của

public class Lazy<T> where T : new() 
{ 
    private T value; 

    public bool IsValueCreated { get; private set;} 

    public T Value 
    { 
    get 
    { 
     if (!IsValueCreated) 
     { 
      value = new T(); 
      IsValueCreated = true; 
     } 
     return value; 
    } 
    } 
} 

Answer 4

Một số hài hước (nhưng không phải là rất có thể sử dụng) công cụ có thể được thêm aaron của: coversion ngầm từ đại biểu:

public static implicit operator Lazy<T>(Func<T> initializer) 
{ 
    return new Lazy<T>(initializer); 
} 

Và sử dụng

private static Lazy<int> Value = new Func<int>(() => 24 * 22); 

Trình biên dịch C# có một số vấn đề với việc thực hiện chuyển đổi này, ví dụ gán biểu thức lambda không hoạt động, nhưng một điều nữa khiến cho các đồng nghiệp của bạn suy nghĩ một chút :)