Lazy<T> Lazy<T> Lazy<T> Lazy<T> Class

Definition

Обеспечивает поддержку отложенной инициализации. Provides support for lazy initialization.

generic <typename T>
public ref class Lazy
[System.Runtime.InteropServices.ComVisible(false)]
[Serializable]
public class Lazy<T>
type Lazy<'T> = class
Public Class Lazy(Of T)

Type Parameters

T

Тип объекта с отложенной инициализацией. The type of object that is being lazily initialized.

Inheritance
Lazy<T>Lazy<T>Lazy<T>Lazy<T>
Derived
Attributes
ComVisibleAttribute SerializableAttribute

Examples

В следующем примере показано использование Lazy<T> класса для выполнения отложенной инициализации с доступом из нескольких потоков.The following example demonstrates the use of the Lazy<T> class to provide lazy initialization with access from multiple threads.

Примечание

В примере используется Lazy<T>(Func<T>) конструктор.The example uses the Lazy<T>(Func<T>) constructor. Он также демонстрирует использование Lazy<T>(Func<T>, Boolean) конструктор (указание true для isThreadSafe) и Lazy<T>(Func<T>, LazyThreadSafetyMode) конструктор (указание LazyThreadSafetyMode.ExecutionAndPublication для mode).It also demonstrates the use of the Lazy<T>(Func<T>, Boolean) constructor (specifying true for isThreadSafe) and the Lazy<T>(Func<T>, LazyThreadSafetyMode) constructor (specifying LazyThreadSafetyMode.ExecutionAndPublication for mode). Чтобы переключиться в другой конструктор, просто измените конструкторов, закомментированы.To switch to a different constructor, just change which constructors are commented out.

Пример, демонстрирующий исключение кэширования с помощью же конструкторы, см. в разделе Lazy<T>(Func<T>) конструктор.For an example that demonstrates exception caching using the same constructors, see the Lazy<T>(Func<T>) constructor.

В этом примере определяется класс LargeObject, для которого будет выполняться отложенная инициализация одним из нескольких потоков.The example defines a LargeObject class that will be initialized lazily by one of several threads. Четыре основные разделы кода иллюстрируют Создание инициализатор, метод фабрики, фактическую инициализацию и конструктор LargeObject класс, который выводит сообщение при создании объекта.The four key sections of code illustrate the creation of the initializer, the factory method, the actual initialization, and the constructor of the LargeObject class, which displays a message when the object is created. В начале метода Main в этом примере создается потокобезопасный отложенный инициализатор для класса LargeObject:At the beginning of the Main method, the example creates the thread-safe lazy initializer for LargeObject:

lazyLargeObject = new Lazy<LargeObject>(InitLargeObject);

// The following lines show how to use other constructors to achieve exactly the
// same result as the previous line: 
//lazyLargeObject = new Lazy<LargeObject>(InitLargeObject, true);
//lazyLargeObject = new Lazy<LargeObject>(InitLargeObject, 
//                               LazyThreadSafetyMode.ExecutionAndPublication);
lazyLargeObject = New Lazy(Of LargeObject)(AddressOf InitLargeObject)

' The following lines show how to use other constructors to achieve exactly the
' same result as the previous line: 
'lazyLargeObject = new Lazy<LargeObject>(InitLargeObject, true);
'lazyLargeObject = new Lazy<LargeObject>(InitLargeObject, _
'                               LazyThreadSafetyMode.ExecutionAndPublication);

Фабричный метод показано создание объекта, с заполнителем для дальнейшей инициализации:The factory method shows the creation of the object, with a placeholder for further initialization:

static LargeObject InitLargeObject()
{
    LargeObject large = new LargeObject(Thread.CurrentThread.ManagedThreadId);
    // Perform additional initialization here.
    return large;
}
Private Shared Function InitLargeObject() As LargeObject
    Dim large As New LargeObject(Thread.CurrentThread.ManagedThreadId)
    ' Perform additional initialization here.
    Return large
End Function

Обратите внимание на то, код первых двух разделов, которые можно использовать с помощью лямбда-функцию, как показано ниже:Note that the first two code sections could be combined by using a lambda function, as shown here:

lazyLargeObject = new Lazy<LargeObject>(() => 
{
    LargeObject large = new LargeObject(Thread.CurrentThread.ManagedThreadId);
    // Perform additional initialization here.
    return large;
});
lazyLargeObject = New Lazy(Of LargeObject)(Function () 
    Dim large As New LargeObject(Thread.CurrentThread.ManagedThreadId) 
    ' Perform additional initialization here.
    Return large
End Function)

В примере приостанавливается, чтобы указать, что неопределенное может пройти, прежде чем отложенной инициализации.The example pauses, to indicate that an indeterminate period may elapse before lazy initialization occurs. При нажатии клавиши ввод ключей, в примере создает и запускает три потока.When you press the Enter key, the example creates and starts three threads. ThreadProc Метод, используемый вызовами все три потока Value свойство.The ThreadProc method that's used by all three threads calls the Value property. В первый раз, в этом случае LargeObject создается экземпляр:The first time this happens, the LargeObject instance is created:

LargeObject large = lazyLargeObject.Value;

// IMPORTANT: Lazy initialization is thread-safe, but it doesn't protect the  
//            object after creation. You must lock the object before accessing it,
//            unless the type is thread safe. (LargeObject is not thread safe.)
lock(large)
{
    large.Data[0] = Thread.CurrentThread.ManagedThreadId;
    Console.WriteLine("Initialized by thread {0}; last used by thread {1}.", 
        large.InitializedBy, large.Data[0]);
}
Dim large As LargeObject = lazyLargeObject.Value

' IMPORTANT: Lazy initialization is thread-safe, but it doesn't protect the  
'            object after creation. You must lock the object before accessing it,
'            unless the type is thread safe. (LargeObject is not thread safe.)
SyncLock large
    large.Data(0) = Thread.CurrentThread.ManagedThreadId
    Console.WriteLine("Initialized by thread {0}; last used by thread {1}.", _
        large.InitializedBy, large.Data(0))
End SyncLock

Конструктор LargeObject класса, содержащего последнего ключа раздела кода, отображает сообщение и регистрирует удостоверение поток.The constructor of the LargeObject class, which includes the last key section of code, displays a message and records the identity of the initializing thread. Выходные данные программы отображаются в конце полный отрывок кода.The output from the program appears at the end of the full code listing.

int initBy = 0;
public LargeObject(int initializedBy)
{
    initBy = initializedBy;
    Console.WriteLine("LargeObject was created on thread id {0}.", initBy);
}
Private initBy As Integer = 0
Public Sub New(ByVal initializedBy As Integer)
    initBy = initializedBy
    Console.WriteLine("LargeObject was created on thread id {0}.", initBy)
End Sub

Примечание

Для простоты в этом примере используется глобальный экземпляр класса Lazy<T>, а все методы объявлены как static (Shared в Visual Basic).For simplicity, this example uses a global instance of Lazy<T>, and all the methods are static (Shared in Visual Basic). Это не является обязательными требованиями для использования отложенной инициализации.These are not requirements for the use of lazy initialization.

using System;
using System.Threading;

class Program
{
    static Lazy<LargeObject> lazyLargeObject = null;

    static LargeObject InitLargeObject()
    {
        LargeObject large = new LargeObject(Thread.CurrentThread.ManagedThreadId);
        // Perform additional initialization here.
        return large;
    }
    

    static void Main()
    {
        // The lazy initializer is created here. LargeObject is not created until the 
        // ThreadProc method executes.
        lazyLargeObject = new Lazy<LargeObject>(InitLargeObject);

        // The following lines show how to use other constructors to achieve exactly the
        // same result as the previous line: 
        //lazyLargeObject = new Lazy<LargeObject>(InitLargeObject, true);
        //lazyLargeObject = new Lazy<LargeObject>(InitLargeObject, 
        //                               LazyThreadSafetyMode.ExecutionAndPublication);


        Console.WriteLine(
            "\r\nLargeObject is not created until you access the Value property of the lazy" +
            "\r\ninitializer. Press Enter to create LargeObject.");
        Console.ReadLine();

        // Create and start 3 threads, each of which uses LargeObject.
        Thread[] threads = new Thread[3];
        for (int i = 0; i < 3; i++)
        {
            threads[i] = new Thread(ThreadProc);
            threads[i].Start();
        }

        // Wait for all 3 threads to finish. 
        foreach (Thread t in threads)
        {
            t.Join();
        }

        Console.WriteLine("\r\nPress Enter to end the program");
        Console.ReadLine();
    }


    static void ThreadProc(object state)
    {
        LargeObject large = lazyLargeObject.Value;

        // IMPORTANT: Lazy initialization is thread-safe, but it doesn't protect the  
        //            object after creation. You must lock the object before accessing it,
        //            unless the type is thread safe. (LargeObject is not thread safe.)
        lock(large)
        {
            large.Data[0] = Thread.CurrentThread.ManagedThreadId;
            Console.WriteLine("Initialized by thread {0}; last used by thread {1}.", 
                large.InitializedBy, large.Data[0]);
        }
    }
}

class LargeObject
{
    public int InitializedBy { get { return initBy; } }

    int initBy = 0;
    public LargeObject(int initializedBy)
    {
        initBy = initializedBy;
        Console.WriteLine("LargeObject was created on thread id {0}.", initBy);
    }

    public long[] Data = new long[100000000];
}

/* This example produces output similar to the following:

LargeObject is not created until you access the Value property of the lazy
initializer. Press Enter to create LargeObject.

LargeObject was created on thread id 3.
Initialized by thread 3; last used by thread 3.
Initialized by thread 3; last used by thread 4.
Initialized by thread 3; last used by thread 5.

Press Enter to end the program
 */
Imports System
Imports System.Threading

Friend Class Program
    Private Shared lazyLargeObject As Lazy(Of LargeObject) = Nothing

    Private Shared Function InitLargeObject() As LargeObject
        Dim large As New LargeObject(Thread.CurrentThread.ManagedThreadId)
        ' Perform additional initialization here.
        Return large
    End Function


    Shared Sub Main()
        ' The lazy initializer is created here. LargeObject is not created until the 
        ' ThreadProc method executes.
        lazyLargeObject = New Lazy(Of LargeObject)(AddressOf InitLargeObject)

        ' The following lines show how to use other constructors to achieve exactly the
        ' same result as the previous line: 
        'lazyLargeObject = new Lazy<LargeObject>(InitLargeObject, true);
        'lazyLargeObject = new Lazy<LargeObject>(InitLargeObject, _
        '                               LazyThreadSafetyMode.ExecutionAndPublication);


        Console.WriteLine(vbCrLf & _
            "LargeObject is not created until you access the Value property of the lazy" _
            & vbCrLf & "initializer. Press Enter to create LargeObject.")
        Console.ReadLine()

        ' Create and start 3 threads, each of which uses LargeObject.
        Dim threads(2) As Thread
        For i As Integer = 0 To 2
            threads(i) = New Thread(AddressOf ThreadProc)
            threads(i).Start()
        Next i

        ' Wait for all 3 threads to finish. 
        For Each t As Thread In threads
            t.Join()
        Next t

        Console.WriteLine(vbCrLf & "Press Enter to end the program")
        Console.ReadLine()
    End Sub


    Private Shared Sub ThreadProc(ByVal state As Object)
        Dim large As LargeObject = lazyLargeObject.Value

        ' IMPORTANT: Lazy initialization is thread-safe, but it doesn't protect the  
        '            object after creation. You must lock the object before accessing it,
        '            unless the type is thread safe. (LargeObject is not thread safe.)
        SyncLock large
            large.Data(0) = Thread.CurrentThread.ManagedThreadId
            Console.WriteLine("Initialized by thread {0}; last used by thread {1}.", _
                large.InitializedBy, large.Data(0))
        End SyncLock
    End Sub
End Class

Friend Class LargeObject
    Public ReadOnly Property InitializedBy() As Integer
        Get
            Return initBy
        End Get
    End Property

    Private initBy As Integer = 0
    Public Sub New(ByVal initializedBy As Integer)
        initBy = initializedBy
        Console.WriteLine("LargeObject was created on thread id {0}.", initBy)
    End Sub

    Public Data(99999999) As Long
End Class

' This example produces output similar to the following:
'
'LargeObject is not created until you access the Value property of the lazy
'initializer. Press Enter to create LargeObject.
'
'LargeObject was created on thread id 3.
'Initialized by thread 3; last used by thread 3.
'Initialized by thread 3; last used by thread 5.
'Initialized by thread 3; last used by thread 4.
'
'Press Enter to end the program
' 

Remarks

Используйте отложенную инициализацию отложить создание больших или ресурсоемких объекта или выполнения ресурсоемких задач, особенно в том случае, если такие создания или выполнения могут не выполняться в течение времени существования программы.Use lazy initialization to defer the creation of a large or resource-intensive object, or the execution of a resource-intensive task, particularly when such creation or execution might not occur during the lifetime of the program.

Чтобы подготовить для отложенной инициализации, создания экземпляра Lazy<T>.To prepare for lazy initialization, you create an instance of Lazy<T>. Аргумент типа Lazy<T> , созданный тип объекта, который вы хотите инициализировать неактивно.The type argument of the Lazy<T> object that you create specifies the type of the object that you want to initialize lazily. Конструктор, который используется для создания Lazy<T> объекта определяет характеристики инициализации.The constructor that you use to create the Lazy<T> object determines the characteristics of the initialization. Отложенная инициализация производится при первом обращении к свойству Lazy<T>.Value.Lazy initialization occurs the first time the Lazy<T>.Value property is accessed.

В большинстве случаев выбор конструктор зависит ответы на два вопроса:In most cases, choosing a constructor depends on your answers to two questions:

  • Неактивно инициализированного объекта будут доступны из более чем одного потока?Will the lazily initialized object be accessed from more than one thread? Если Да, Lazy<T> объект может создать в любом потоке.If so, the Lazy<T> object might create it on any thread. Можно использовать один из простых конструкторов, поведение которого по умолчанию является создание поточно ориентированной Lazy<T> объекта, так что только один экземпляр неактивно обрабатываемого объекта создается независимо от того, сколько потока пытаются получить доступ к нему.You can use one of the simple constructors whose default behavior is to create a thread-safe Lazy<T> object, so that only one instance of the lazily instantiated object is created no matter how many threads try to access it. Для создания Lazy<T> объекта, который не является потокобезопасным, необходимо использовать конструктор, который позволяет указать без потокобезопасности.To create a Lazy<T> object that is not thread safe, you must use a constructor that enables you to specify no thread safety.

    Внимание!

    Что делает Lazy<T> объект поточно-ориентированным не защищает неактивно инициализированного объекта.Making the Lazy<T> object thread safe does not protect the lazily initialized object. Если несколько потоков могут получить доступ к неактивно инициализированного объекта, необходимо убедиться в его свойства и методы безопасными для многопоточного доступа.If multiple threads can access the lazily initialized object, you must make its properties and methods safe for multithreaded access.

  • Отложенная инициализация требует большого объема кода, или неактивно инициализированного объекта имеет конструктор по умолчанию, который выполняет все, что нужно и не вызывать исключения?Does lazy initialization require a lot of code, or does the lazily initialized object have a default constructor that does everything you need and doesn't throw exceptions? Если вам нужно написать код инициализации, или если необходимо обрабатывать исключения, используйте один из конструкторов, принимающих метод фабрики.If you need to write initialization code or if exceptions need to be handled, use one of the constructors that takes a factory method. Запишите свой код инициализации в методе фабрики.Write your initialization code in the factory method.

В следующей таблице показаны, чтобы выбрать, какой конструктор на основе этих двух факторов:The following table shows which constructor to choose, based on these two factors:

Объект, которые будут доступны дляObject will be accessed by Если требуется никакого кода инициализации (конструктор по умолчанию), используйтеIf no initialization code is required (default constructor), use Если код инициализации, используйтеIf initialization code is required, use
Несколько потоковMultiple threads Lazy<T>() Lazy<T>(Func<T>)
Один потокOne thread Lazy<T>(Boolean) с помощью isThreadSafe присвоено false.Lazy<T>(Boolean) with isThreadSafe set to false. Lazy<T>(Func<T>, Boolean) с помощью isThreadSafe присвоено false.Lazy<T>(Func<T>, Boolean) with isThreadSafe set to false.

Лямбда-выражения можно использовать для указания метода фабрики.You can use a lambda expression to specify the factory method. В этом случае всех кодов инициализации в одном месте.This keeps all the initialization code in one place. Лямбда-выражение захватывает контекст, включая все аргументы, передаваемые конструктору объекта отложенной инициализацией.The lambda expression captures the context, including any arguments you pass to the lazily initialized object's constructor.

Кэширование исключений при использовании фабричные методы исключения кэшируются.Exception caching When you use factory methods, exceptions are cached. То есть если фабричный метод создает исключение времени исключение первый поток пытается получить доступ к Value свойство Lazy<T> объекта, то же исключение возникает при всех последующих попытках.That is, if the factory method throws an exception the first time a thread tries to access the Value property of the Lazy<T> object, the same exception is thrown on every subsequent attempt. Это гарантирует, что при каждом вызове Value свойство дает тот же результат и позволяет избежать ошибкам, которые могут возникнуть при разных потоков получить разные результаты.This ensures that every call to the Value property produces the same result and avoids subtle errors that might arise if different threads get different results. Lazy<T> Заменяет реальный T , в противном случае будет инициализировано на более раннем этапе, обычно во время запуска.The Lazy<T> stands in for an actual T that otherwise would have been initialized at some earlier point, usually during startup. Сбой на этой более ранней точки является обычно неустранимой.A failure at that earlier point is usually fatal. Если существует вероятность возникновения сбоя восстанавливаемые, мы рекомендуем встраивание логики повторения в процедуре инициализации (в данном случае метод фабрики), так же, как если бы использовали отложенной инициализации.If there is a potential for a recoverable failure, we recommend that you build the retry logic into the initialization routine (in this case, the factory method), just as you would if you weren’t using lazy initialization.

Альтернативой блокировки в определенных ситуациях может потребоваться избежать Lazy<T> объекта по умолчанию работа блокировки.Alternative to locking In certain situations, you might want to avoid the overhead of the Lazy<T> object's default locking behavior. В редких случаях могут быть вероятность возникновения взаимоблокировок.In rare situations, there might be a potential for deadlocks. В таких случаях можно использовать Lazy<T>(LazyThreadSafetyMode) или Lazy<T>(Func<T>, LazyThreadSafetyMode) конструктор и укажите LazyThreadSafetyMode.PublicationOnly.In such cases, you can use the Lazy<T>(LazyThreadSafetyMode) or Lazy<T>(Func<T>, LazyThreadSafetyMode) constructor, and specify LazyThreadSafetyMode.PublicationOnly. Это позволяет Lazy<T> для создания копии неактивно инициализированного объекта на каждом из нескольких потоков, если потоки обращаются к Value свойства одновременно.This enables the Lazy<T> object to create a copy of the lazily initialized object on each of several threads if the threads call the Value property simultaneously. Lazy<T> Объект гарантирует, что все потоки, использовать один и тот же экземпляр объекта с отложенной инициализацией и удаляет экземпляры, которые не используются.The Lazy<T> object ensures that all threads use the same instance of the lazily initialized object and discards the instances that are not used. Таким образом сокращение расходов на блокировку обходится, программа может иногда Создание и удаление дополнительных копий ресурсоемкий объект.Thus, the cost of reducing the locking overhead is that your program might sometimes create and discard extra copies of an expensive object. В большинстве случаев это маловероятно.In most cases, this is unlikely. В примерах для Lazy<T>(LazyThreadSafetyMode) и Lazy<T>(Func<T>, LazyThreadSafetyMode) конструкторы демонстрируют это поведение.The examples for the Lazy<T>(LazyThreadSafetyMode) and Lazy<T>(Func<T>, LazyThreadSafetyMode) constructors demonstrate this behavior.

Важно!

При указании LazyThreadSafetyMode.PublicationOnly, исключения не кэшируются, даже если указать метод фабрики.When you specify LazyThreadSafetyMode.PublicationOnly, exceptions are never cached, even if you specify a factory method.

Эквивалентное конструкторы Помимо возможности использования LazyThreadSafetyMode.PublicationOnly, Lazy<T>(LazyThreadSafetyMode) и Lazy<T>(Func<T>, LazyThreadSafetyMode) конструкторы можно дублировать функции других конструкторов.Equivalent constructors In addition to enabling the use of LazyThreadSafetyMode.PublicationOnly, the Lazy<T>(LazyThreadSafetyMode) and Lazy<T>(Func<T>, LazyThreadSafetyMode) constructors can duplicate the functionality of the other constructors. В следующей таблице показаны значения параметров, которые создают эквивалентное поведение.The following table shows the parameter values that produce equivalent behavior.

Чтобы создать Lazy<T> объект, который отсутствуетTo create a Lazy<T> object that is Для конструкторов, которые имеют LazyThreadSafetyMode mode набор параметров, mode дляFor constructors that have a LazyThreadSafetyMode mode parameter, set mode to Для конструкторов, которые имеют значение типа Boolean isThreadSafe набор параметров, isThreadSafe дляFor constructors that have a Boolean isThreadSafe parameter, set isThreadSafe to Для конструкторов без параметров безопасности потокаFor constructors with no thread safety parameters
Полностью потокобезопасным; использует блокировку для убедитесь, что только один поток инициализирует значение.Fully thread safe; uses locking to ensure that only one thread initializes the value. ExecutionAndPublication true Все конструкторы являются полностью потокобезопасными.All such constructors are fully thread safe.
Не является потокобезопасным.Not thread safe. None false Неприменимо.Not applicable.
Полностью потокобезопасным; потоки состязаются за право инициализации значения.Fully thread safe; threads race to initialize the value. PublicationOnly Неприменимо.Not applicable. Неприменимо.Not applicable.

Другие возможности сведения об использовании Lazy<T> с статических полей потока, или в качестве резервного хранилища для свойств, см. в разделе отложенной инициализации.Other capabilities For information about the use of Lazy<T> with thread-static fields, or as the backing store for properties, see Lazy Initialization.

Constructors

Lazy<T>() Lazy<T>() Lazy<T>() Lazy<T>()

Инициализирует новый экземпляр класса Lazy<T>. Initializes a new instance of the Lazy<T> class. При отложенной инициализации используется конструктор по умолчанию для целевого типа. When lazy initialization occurs, the default constructor of the target type is used.

Lazy<T>(Boolean) Lazy<T>(Boolean) Lazy<T>(Boolean) Lazy<T>(Boolean)

Инициализирует новый экземпляр класса Lazy<T>. Initializes a new instance of the Lazy<T> class. При отложенной инициализации используется конструктор по умолчанию целевого типа и указанный режим инициализации. When lazy initialization occurs, the default constructor of the target type and the specified initialization mode are used.

Lazy<T>(Func<T>) Lazy<T>(Func<T>) Lazy<T>(Func<T>) Lazy<T>(Func<T>)

Инициализирует новый экземпляр класса Lazy<T>. Initializes a new instance of the Lazy<T> class. Когда происходит отложенная инициализация, используется заданная функция инициализации. When lazy initialization occurs, the specified initialization function is used.

Lazy<T>(Func<T>, Boolean) Lazy<T>(Func<T>, Boolean) Lazy<T>(Func<T>, Boolean) Lazy<T>(Func<T>, Boolean)

Инициализирует новый экземпляр класса Lazy<T>. Initializes a new instance of the Lazy<T> class. Когда происходит отложенная инициализация, используются заданные функция инициализации и режим инициализации. When lazy initialization occurs, the specified initialization function and initialization mode are used.

Lazy<T>(Func<T>, LazyThreadSafetyMode) Lazy<T>(Func<T>, LazyThreadSafetyMode) Lazy<T>(Func<T>, LazyThreadSafetyMode) Lazy<T>(Func<T>, LazyThreadSafetyMode)

Инициализирует новый экземпляр класса Lazy<T>, который использует заданную функцию инициализации и потокобезопасный режим. Initializes a new instance of the Lazy<T> class that uses the specified initialization function and thread-safety mode.

Lazy<T>(LazyThreadSafetyMode) Lazy<T>(LazyThreadSafetyMode) Lazy<T>(LazyThreadSafetyMode) Lazy<T>(LazyThreadSafetyMode)

Инициализирует новый экземпляр класса Lazy<T>, который использует конструктор T по умолчанию и заданный потокобезопасный режим. Initializes a new instance of the Lazy<T> class that uses the default constructor of T and the specified thread-safety mode.

Lazy<T>(T) Lazy<T>(T) Lazy<T>(T) Lazy<T>(T)

Properties

IsValueCreated IsValueCreated IsValueCreated IsValueCreated

Получает значение, указывающее, было ли создано значение для данного экземпляра Lazy<T>. Gets a value that indicates whether a value has been created for this Lazy<T> instance.

Value Value Value Value

Получает неактивно инициализированное значение текущего экземпляра Lazy<T>. Gets the lazily initialized value of the current Lazy<T> instance.

Methods

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Определяет, равен ли заданный объект текущему объекту. Determines whether the specified object is equal to the current object.

(Inherited from Object)
GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Служит хэш-функцией по умолчанию. Serves as the default hash function.

(Inherited from Object)
GetType() GetType() GetType() GetType()

Возвращает объект Type для текущего экземпляра. Gets the Type of the current instance.

(Inherited from Object)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Создает неполную копию текущего объекта Object. Creates a shallow copy of the current Object.

(Inherited from Object)
ToString() ToString() ToString() ToString()

Создает и возвращает строковое представление свойства Value данного экземпляра. Creates and returns a string representation of the Value property for this instance.

Applies to

Thread Safety

По умолчанию, все открытые и защищенные члены Lazy<T> класса являются потокобезопасными и могут быть использованы одновременно из нескольких потоков. By default, all public and protected members of the Lazy<T> class are thread safe and may be used concurrently from multiple threads. Эти потокобезопасности могут быть удалены, при необходимости и экземпляра, используя параметры типа. These thread-safety guarantees may be removed optionally and per instance, using parameters to the type's constructors.

See Also