Lazy<T> Classe

Definizione

Fornisce supporto per l'inizializzazione differita.Provides support for lazy initialization.

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

Parametri di tipo

T

Tipo di oggetto inizializzato in modalità differita.The type of object that is being lazily initialized.

Ereditarietà
Lazy<T>
Derivato
Attributi

Esempi

Nell'esempio seguente viene illustrato l'utilizzo della Lazy<T> classe per fornire l'inizializzazione Lazy con accesso da più thread.The following example demonstrates the use of the Lazy<T> class to provide lazy initialization with access from multiple threads.

Nota

Nell'esempio viene usato Lazy<T>(Func<T>) il costruttore.The example uses the Lazy<T>(Func<T>) constructor. Viene inoltre illustrato l'utilizzo del Lazy<T>(Func<T>, Boolean) Costruttore (specificando true per isThreadSafe) e del Lazy<T>(Func<T>, LazyThreadSafetyMode) Costruttore (specificando mode LazyThreadSafetyMode.ExecutionAndPublication per).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). Per passare a un costruttore diverso, è sufficiente modificare i costruttori impostati come commento.To switch to a different constructor, just change which constructors are commented out.

Per un esempio in cui viene illustrata la memorizzazione delle eccezioni nella cache usando gli Lazy<T>(Func<T>) stessi costruttori, vedere il costruttore.For an example that demonstrates exception caching using the same constructors, see the Lazy<T>(Func<T>) constructor.

Nell'esempio viene definita una classe LargeObject che verrà inizializzata in modo differito da uno dei diversi thread.The example defines a LargeObject class that will be initialized lazily by one of several threads. Nelle quattro sezioni principali del codice viene illustrata la creazione dell'inizializzatore, il metodo factory, l'inizializzazione effettiva e il costruttore della LargeObject classe, che visualizza un messaggio quando viene creato l'oggetto.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. All'inizio del metodo Main, viene creato un inizializzatore thread-safe differito per 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(Of LargeObject)(AddressOf InitLargeObject, True)
'lazyLargeObject = New Lazy(Of LargeObject)(AddressOf InitLargeObject, _
'                               LazyThreadSafetyMode.ExecutionAndPublication)

Il metodo factory Mostra la creazione dell'oggetto, con un segnaposto per un'ulteriore inizializzazione: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

Si noti che le prime due sezioni di codice possono essere combinate usando una funzione lambda, come illustrato di seguito: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)

L'esempio viene sospeso per indicare che un periodo indeterminato può trascorrere prima che venga eseguita l'inizializzazione Lazy.The example pauses, to indicate that an indeterminate period may elapse before lazy initialization occurs. Quando si preme il tasto invio , l'esempio crea e avvia tre thread.When you press the Enter key, the example creates and starts three threads. Il ThreadProc metodo usato da tutti e tre i thread chiama la Value proprietà.The ThreadProc method that's used by all three threads calls the Value property. La prima volta che si verifica questa LargeObject situazione, viene creata l'istanza: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

Il costruttore della LargeObject classe, che include l'ultima sezione chiave del codice, Visualizza un messaggio e registra l'identità del thread di inizializzazione.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. L'output del programma viene visualizzato alla fine del listato di codice completo.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

Nota

Per semplicità, in questo esempio viene utilizzata un'istanza globale di Lazy<T> e tutti i metodi sono static (Shared in Visual Basic).For simplicity, this example uses a global instance of Lazy<T>, and all the methods are static (Shared in Visual Basic). Questi non sono requisiti per l'uso di inizializzazione differita.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.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(Of LargeObject)(AddressOf InitLargeObject, True)
        'lazyLargeObject = New Lazy(Of LargeObject)(AddressOf 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
' 

Commenti

Usare l'inizializzazione differita per rinviare la creazione di un oggetto grande o a elevato utilizzo di risorse o l'esecuzione di un'attività a elevato utilizzo di risorse, in particolare quando tale creazione o esecuzione potrebbe non verificarsi durante il ciclo di vita del programma.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.

Per preparare l'inizializzazione differita, creare un'istanza Lazy<T>di.To prepare for lazy initialization, you create an instance of Lazy<T>. L'argomento tipo dell' Lazy<T> oggetto creato specifica il tipo di oggetto che si desidera inizializzare in modo differito.The type argument of the Lazy<T> object that you create specifies the type of the object that you want to initialize lazily. Il costruttore utilizzato per creare l' Lazy<T> oggetto determina le caratteristiche dell'inizializzazione.The constructor that you use to create the Lazy<T> object determines the characteristics of the initialization. L'inizializzazione differita viene eseguita la prima volta che si accede alla proprietà Lazy<T>.Value.Lazy initialization occurs the first time the Lazy<T>.Value property is accessed.

Nella maggior parte dei casi, la scelta di un costruttore dipende dalle risposte a due domande:In most cases, choosing a constructor depends on your answers to two questions:

  • È possibile accedere all'oggetto inizializzato in modo differito da più di un thread?Will the lazily initialized object be accessed from more than one thread? In tal caso, Lazy<T> l'oggetto può crearlo in qualsiasi thread.If so, the Lazy<T> object might create it on any thread. È possibile usare uno dei costruttori semplici il cui comportamento predefinito consiste nel creare un oggetto thread-safe Lazy<T> , in modo che venga creata solo un'istanza dell'oggetto di cui è stata creata un'istanza, indipendentemente dal numero di thread che tentano di accedervi.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. Per creare un Lazy<T> oggetto non thread-safe, è necessario usare un costruttore che consente di specificare nessun thread safety.To create a Lazy<T> object that is not thread safe, you must use a constructor that enables you to specify no thread safety.

    Attenzione

    Rendere thread Lazy<T> -safe l'oggetto non protegge l'oggetto inizializzato in modo differito.Making the Lazy<T> object thread safe does not protect the lazily initialized object. Se più thread possono accedere all'oggetto inizializzato in modo differito, è necessario rendere i relativi metodi e proprietà sicuri per l'accesso multithread.If multiple threads can access the lazily initialized object, you must make its properties and methods safe for multithreaded access.

  • L'inizializzazione differita richiede una grande quantità di codice oppure l'oggetto inizializzato in modo differito ha un costruttore senza parametri che esegue tutte le operazioni necessarie e non genera eccezioni?Does lazy initialization require a lot of code, or does the lazily initialized object have a parameterless constructor that does everything you need and doesn't throw exceptions? Se è necessario scrivere codice di inizializzazione o se è necessario gestire le eccezioni, usare uno dei costruttori che accetta un metodo factory.If you need to write initialization code or if exceptions need to be handled, use one of the constructors that takes a factory method. Scrivere il codice di inizializzazione nel metodo factory.Write your initialization code in the factory method.

Nella tabella seguente viene illustrato il costruttore da scegliere, in base a questi due fattori:The following table shows which constructor to choose, based on these two factors:

L'oggetto sarà accessibile daObject will be accessed by Se non è richiesto alcun codice di inizializzazione (costruttore senza parametri), usareIf no initialization code is required (parameterless constructor), use Se il codice di inizializzazione è obbligatorio, usareIf initialization code is required, use
Più threadMultiple threads Lazy<T>() Lazy<T>(Func<T>)
Un threadOne thread Lazy<T>(Boolean)con isThreadSafe impostato su false.Lazy<T>(Boolean) with isThreadSafe set to false. Lazy<T>(Func<T>, Boolean)con isThreadSafe impostato su false.Lazy<T>(Func<T>, Boolean) with isThreadSafe set to false.

È possibile usare un'espressione lambda per specificare il metodo factory.You can use a lambda expression to specify the factory method. Questo consente di mantenere tutto il codice di inizializzazione in un'unica posizione.This keeps all the initialization code in one place. L'espressione lambda acquisisce il contesto, inclusi eventuali argomenti passati al costruttore dell'oggetto inizializzato in modo differito.The lambda expression captures the context, including any arguments you pass to the lazily initialized object's constructor.

Caching delle eccezioni Quando si usano i metodi factory, le eccezioni vengono memorizzate nella cache.Exception caching When you use factory methods, exceptions are cached. Ovvero, se il metodo factory genera un'eccezione la prima volta che un thread tenta di accedere alla Value proprietà Lazy<T> dell'oggetto, viene generata la stessa eccezione a ogni tentativo successivo.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. Ciò garantisce che ogni chiamata alla Value proprietà produca lo stesso risultato ed eviti errori sottili che possono verificarsi se thread diversi ottengono risultati diversi.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. Si Lazy<T> trova in per un effettivo T che altrimenti sarebbe stato inizializzato in un punto precedente, in genere durante l'avvio.The Lazy<T> stands in for an actual T that otherwise would have been initialized at some earlier point, usually during startup. Un errore in quel punto precedente è in genere irreversibile.A failure at that earlier point is usually fatal. Se è possibile che si verifichi un errore reversibile, è consigliabile compilare la logica di ripetizione dei tentativi nella routine di inizializzazione (in questo caso, il metodo Factory), come se non si utilizzasse l'inizializzazione Lazy.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.

Alternativa a blocco In alcune situazioni, può essere utile evitare il sovraccarico del comportamento di Lazy<T> blocco predefinito dell'oggetto.Alternative to locking In certain situations, you might want to avoid the overhead of the Lazy<T> object's default locking behavior. In rari casi, è possibile che si verifichino dei deadlock.In rare situations, there might be a potential for deadlocks. In questi casi, è possibile usare il Lazy<T>(LazyThreadSafetyMode) costruttore Lazy<T>(Func<T>, LazyThreadSafetyMode) o e specificare LazyThreadSafetyMode.PublicationOnly.In such cases, you can use the Lazy<T>(LazyThreadSafetyMode) or Lazy<T>(Func<T>, LazyThreadSafetyMode) constructor, and specify LazyThreadSafetyMode.PublicationOnly. Ciò consente all' Lazy<T> oggetto di creare una copia dell'oggetto inizializzato in modo differito in ognuno dei diversi thread se i Value thread chiamano la proprietà contemporaneamente.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. L' Lazy<T> oggetto garantisce che tutti i thread usino la stessa istanza dell'oggetto inizializzato in modo differito e elimini le istanze non utilizzate.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. Pertanto, il costo della riduzione del sovraccarico del blocco è che il programma può talvolta creare ed eliminare copie aggiuntive di un oggetto dispendioso.Thus, the cost of reducing the locking overhead is that your program might sometimes create and discard extra copies of an expensive object. Nella maggior parte dei casi, questo è improbabile.In most cases, this is unlikely. Gli esempi per i Lazy<T>(LazyThreadSafetyMode) costruttori Lazy<T>(Func<T>, LazyThreadSafetyMode) e dimostrano questo comportamento.The examples for the Lazy<T>(LazyThreadSafetyMode) and Lazy<T>(Func<T>, LazyThreadSafetyMode) constructors demonstrate this behavior.

Importante

Quando si specifica LazyThreadSafetyMode.PublicationOnly, le eccezioni non vengono mai memorizzate nella cache, anche se si specifica un metodo factory.When you specify LazyThreadSafetyMode.PublicationOnly, exceptions are never cached, even if you specify a factory method.

Costruttori equivalenti Oltre ad abilitare l'utilizzo di LazyThreadSafetyMode.PublicationOnly, i Lazy<T>(LazyThreadSafetyMode) costruttori e Lazy<T>(Func<T>, LazyThreadSafetyMode) possono duplicare la funzionalità degli altri costruttori.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. Nella tabella seguente vengono illustrati i valori dei parametri che producono un comportamento equivalente.The following table shows the parameter values that produce equivalent behavior.

Per creare un Lazy<T> oggettoTo create a Lazy<T> object that is Per i costruttori che dispongono di LazyThreadSafetyMode un mode parametro, mode impostare suFor constructors that have a LazyThreadSafetyMode mode parameter, set mode to Per i costruttori che dispongono di un isThreadSafe parametro booleano isThreadSafe , impostare suFor constructors that have a Boolean isThreadSafe parameter, set isThreadSafe to Per i costruttori senza parametri di thread safetyFor constructors with no thread safety parameters
Thread-safe completamente Usa il blocco per garantire che il valore venga inizializzato solo da un thread.Fully thread safe; uses locking to ensure that only one thread initializes the value. ExecutionAndPublication true Tutti questi costruttori sono completamente thread-safe.All such constructors are fully thread safe.
Non thread-safe.Not thread safe. None false Non applicabile.Not applicable.
Thread-safe completamente thread Race per inizializzare il valore.Fully thread safe; threads race to initialize the value. PublicationOnly Non applicabile.Not applicable. Non applicabile.Not applicable.

Altre funzionalità Per informazioni sull'uso di con Lazy<T> i campi statici del thread o come archivio di backup per le proprietà, vedere inizializzazione differita.Other capabilities For information about the use of Lazy<T> with thread-static fields, or as the backing store for properties, see Lazy Initialization.

Costruttori

Lazy<T>()

Inizializza una nuova istanza della classe Lazy<T>.Initializes a new instance of the Lazy<T> class. In caso di inizializzazione differita, viene usato il costruttore senza parametri del tipo di destinazione.When lazy initialization occurs, the parameterless constructor of the target type is used.

Lazy<T>(Boolean)

Inizializza una nuova istanza della classe Lazy<T>.Initializes a new instance of the Lazy<T> class. In caso di inizializzazione differita, vengono usati il costruttore senza parametri del tipo di destinazione e la modalità di inizializzazione specificata.When lazy initialization occurs, the parameterless constructor of the target type and the specified initialization mode are used.

Lazy<T>(Func<T>)

Inizializza una nuova istanza della classe Lazy<T>.Initializes a new instance of the Lazy<T> class. Quando si verifica l'inizializzazione differita, viene utilizzata la funzione di inizializzazione specificata.When lazy initialization occurs, the specified initialization function is used.

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

Inizializza una nuova istanza della classe Lazy<T>.Initializes a new instance of the Lazy<T> class. Quando si verifica l'inizializzazione differita, vengono utilizzate la funzione di inizializzazione e la modalità di inizializzazione specificate.When lazy initialization occurs, the specified initialization function and initialization mode are used.

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

Inizializza una nuova istanza della classe Lazy<T> che utilizza la funzione di inizializzazione e la modalità di thread safety specificate.Initializes a new instance of the Lazy<T> class that uses the specified initialization function and thread-safety mode.

Lazy<T>(LazyThreadSafetyMode)

Inizializza una nuova istanza della classe Lazy<T> che usa il costruttore senza parametri di T e la modalità di thread safety specificata.Initializes a new instance of the Lazy<T> class that uses the parameterless constructor of T and the specified thread-safety mode.

Lazy<T>(T)

Inizializza una nuova istanza della classe Lazy<T> che usa un valore preinizializzato specificato.Initializes a new instance of the Lazy<T> class that uses a preinitialized specified value.

Proprietà

IsValueCreated

Ottiene un valore che indica se per questa istanza di Lazy<T> è stato creato un valore.Gets a value that indicates whether a value has been created for this Lazy<T> instance.

Value

Ottiene il valore inizializzato in modalità differita dell'istanza di Lazy<T> corrente.Gets the lazily initialized value of the current Lazy<T> instance.

Metodi

Equals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente.Determines whether the specified object is equal to the current object.

(Ereditato da Object)
GetHashCode()

Funge da funzione hash predefinita.Serves as the default hash function.

(Ereditato da Object)
GetType()

Ottiene l'oggetto Type dell'istanza corrente.Gets the Type of the current instance.

(Ereditato da Object)
MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.Creates a shallow copy of the current Object.

(Ereditato da Object)
ToString()

Crea e restituisce una rappresentazione di stringa della proprietà Value per questa istanza.Creates and returns a string representation of the Value property for this instance.

Si applica a

Thread safety

Per impostazione predefinita, tutti i membri pubblici e protetti Lazy<T> della classe sono thread-safe e possono essere usati contemporaneamente da più thread.By default, all public and protected members of the Lazy<T> class are thread safe and may be used concurrently from multiple threads. Queste garanzie di thread safety possono essere rimosse facoltativamente e per istanza, usando i parametri per i costruttori del tipo.These thread-safety guarantees may be removed optionally and per instance, using parameters to the type's constructors.

Vedi anche