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

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>Lazy<T>Lazy<T>Lazy<T>
Derivato
Attributi

Esempi

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

Per un esempio che illustra l'eccezione di memorizzazione nella cache usando i costruttori stesso, vedere il Lazy<T>(Func<T>) 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. Le quattro sezioni principali di codice illustrano la creazione di inizializzatore, al metodo factory, l'effettiva inizializzazione e il costruttore del 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<LargeObject>(InitLargeObject, true);
'lazyLargeObject = new Lazy<LargeObject>(InitLargeObject, _
'                               LazyThreadSafetyMode.ExecutionAndPublication);

Il metodo factory illustra 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 sezioni di codice prima di tutto due 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)

Nell'esempio viene sospeso, per indicare che può intercorrere un periodo di tempo indeterminato prima che venga eseguita l'inizializzazione differita.The example pauses, to indicate that an indeterminate period may elapse before lazy initialization occurs. Quando si preme il invio chiave, 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 tutte le chiamate di tre thread di Value proprietà.The ThreadProc method that's used by all three threads calls the Value property. La prima volta in questo caso, il LargeObject istanza viene creata: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 del LargeObject (classe), che include l'ultima sezione chiave del codice, viene visualizzato un messaggio e registra l'identità del thread durante l'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
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
' 

Commenti

Usare l'inizializzazione differita per rinviare la creazione di un oggetto di grandi dimensioni 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 nel corso della durata 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 per l'inizializzazione differita, si crea un'istanza di Lazy<T>.To prepare for lazy initialization, you create an instance of Lazy<T>. L'argomento del tipo di 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 il 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 le risposte alle due domande:In most cases, choosing a constructor depends on your answers to two questions:

  • L'oggetto inizializzato in modo differito sarà accessibili da più di un thread?Will the lazily initialized object be accessed from more than one thread? In questo caso, il Lazy<T> oggetto possibile crearlo in qualsiasi thread.If so, the Lazy<T> object might create it on any thread. È possibile usare uno dei costruttori di semplice il cui comportamento predefinito consiste nel creare un thread-safe Lazy<T> dell'oggetto, in modo che solo un'istanza dell'oggetto in modo differito creata un'istanza viene creata indipendentemente dal numero di thread tenta 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 che non è thread-safe, è necessario usare un costruttore che consente di non specificare alcun thread-safe.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

    Effettua il Lazy<T> affidabile oggetto ma 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 modalità differita, è necessario apportare relativi metodi e proprietà sicuri per l'accesso a thread multipli.If multiple threads can access the lazily initialized object, you must make its properties and methods safe for multithreaded access.

  • L'oggetto inizializzato in modo differito dispone un costruttore predefinito che esegue tutto ciò che è necessario e non genera eccezioni o l'inizializzazione differita richiede una grande quantità di codice?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? Se è necessario scrivere codice di inizializzazione o se le eccezioni devono essere gestiti, usare uno dei costruttori che accettano 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.

La tabella seguente illustra il costruttore di scegliere, in base a questi due fattori:The following table shows which constructor to choose, based on these two factors:

Oggetto eseguiranno l'accesso aObject will be accessed by Se è necessario alcun codice di inizializzazione (costruttore predefinito), usareIf no initialization code is required (default constructor), use Se il codice di inizializzazione è necessario, utilizzareIf 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. In questo modo 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 gli eventuali argomenti passati al costruttore dell'oggetto inizializzato in modalità differita.The lambda expression captures the context, including any arguments you pass to the lazily initialized object's constructor.

La memorizzazione nella cache di eccezione quando si utilizzano metodi factory, le eccezioni vengono memorizzate nella cache.Exception caching When you use factory methods, exceptions are cached. Vale a dire, se il metodo factory genera ora un'eccezione al primo un thread tenta di accedere il Value proprietà del Lazy<T> dell'oggetto, la stessa eccezione viene generata in tutti i tentativi successivi.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 al Value proprietà produce lo stesso risultato e consente di evitare errori che potrebbero verificarsi se diversi thread ottengano 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. Il Lazy<T> sostituisce un vero e proprio T che in caso contrario, verrebbe sono state inizializzate in precedenza, 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. È in genere irreversibile un errore in tale punto precedente.A failure at that earlier point is usually fatal. Se è presente un potenziale di un errore reversibile, è consigliabile compilare la logica di ripetizione dei tentativi nelle routine di inizializzazione (in questo caso il metodo factory), esattamente come farebbe se non è stato usato l'inizializzazione differita.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.

In alternativa al blocco In alcuni casi, si potrebbe voler evitare l'overhead del Lazy<T> comportamento di 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, potrebbero esserci può causare un deadlock.In rare situations, there might be a potential for deadlocks. In questi casi, è possibile usare la Lazy<T>(LazyThreadSafetyMode) oppure Lazy<T>(Func<T>, LazyThreadSafetyMode) costruttore 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. In questo modo, il Lazy<T> oggetto per creare una copia dell'oggetto inizializzato in modo differito in ognuno dei diversi thread se il thread chiama il Value 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. Il Lazy<T> oggetto assicura che tutti i thread di usare la stessa istanza dell'oggetto inizializzato in modo differito ed Elimina le istanze che non vengono usate.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. Di conseguenza, il costo di ridurre l'overhead dei blocchi è che il programma potrebbe a volte creare e rimuovere 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, è improbabile che ciò.In most cases, this is unlikely. Gli esempi per la Lazy<T>(LazyThreadSafetyMode) e Lazy<T>(Func<T>, LazyThreadSafetyMode) costruttori 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 memorizzati 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 a consentire l'uso di LazyThreadSafetyMode.PublicationOnly, il Lazy<T>(LazyThreadSafetyMode) e Lazy<T>(Func<T>, LazyThreadSafetyMode) costruttori possono duplicano la funzionalità di 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 mostra 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 hanno una LazyThreadSafetyMode mode set di parametri, mode aFor constructors that have a LazyThreadSafetyMode mode parameter, set mode to Per i costruttori che hanno un valore booleano isThreadSafe set di parametri, isThreadSafe aFor constructors that have a Boolean isThreadSafe parameter, set isThreadSafe to Per i costruttori senza parametri di thread safetyFor constructors with no thread safety parameters
Completamente thread-safe. Usa il blocco per garantire che un solo thread Inizializza il valore.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 i thread-safe.Not thread safe. None false Non applicabile.Not applicable.
Completamente thread-safe. competizione di thread 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 dello Lazy<T> con i campi di thread statiche o 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>() Lazy<T>() Lazy<T>() Lazy<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 utilizzato il costruttore predefinito del tipo di destinazione.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)

Inizializza una nuova istanza della classe Lazy<T>.Initializes a new instance of the Lazy<T> class. Quando si verifica l'inizializzazione differita, vengono utilizzati il costruttore predefinito del tipo di destinazione e la modalità di inizializzazione specificata.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>)

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) Lazy<T>(Func<T>, Boolean) Lazy<T>(Func<T>, Boolean) 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) Lazy<T>(Func<T>, LazyThreadSafetyMode) Lazy<T>(Func<T>, LazyThreadSafetyMode) 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) Lazy<T>(LazyThreadSafetyMode) Lazy<T>(LazyThreadSafetyMode) Lazy<T>(LazyThreadSafetyMode)

Inizializza una nuova istanza della classe Lazy<T> che utilizza il costruttore predefinito di T e la modalità di thread safety specificata.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)

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 IsValueCreated IsValueCreated 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 Value Value 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) Equals(Object) Equals(Object) Equals(Object)

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

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

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

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

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

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

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

(Inherited from Object)
ToString() ToString() ToString() 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 del Lazy<T> classe sono thread-safe e possono essere utilizzati 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. Facoltativamente e per ogni istanza, utilizzando i parametri nei costruttori del tipo, è possibile rimuovere queste garanzie di thread safety.These thread-safety guarantees may be removed optionally and per instance, using parameters to the type's constructors.

Vedi anche