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

Definition

Unterstützt die verzögerte Initialisierung.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)

Typparameter

T

Der Objekttyp, der verzögert initialisiert wird.The type of object that is being lazily initialized.

Vererbung
Lazy<T>Lazy<T>Lazy<T>Lazy<T>
Abgeleitet
Attribute

Beispiele

Im folgenden Beispiel wird veranschaulicht, wie die Lazy<T> -Klasse verwendet wird, um eine verzögerte Initialisierung mit Zugriff von mehreren Threads bereitzustellen.The following example demonstrates the use of the Lazy<T> class to provide lazy initialization with access from multiple threads.

Hinweis

Im Beispiel wird der Lazy<T>(Func<T>) -Konstruktor verwendet.The example uses the Lazy<T>(Func<T>) constructor. Außerdem wird die Verwendung des Lazy<T>(Func<T>, Boolean) -Konstruktors (mit Angabe true von für isThreadSafe) und Lazy<T>(Func<T>, LazyThreadSafetyMode) des-Konstruktors LazyThreadSafetyMode.ExecutionAndPublication ( modedurch Angabe von für) veranschaulicht.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). Um zu einem anderen Konstruktor zu wechseln, ändern Sie einfach, welche Konstruktoren auskommentiert werden.To switch to a different constructor, just change which constructors are commented out.

Ein Beispiel, das das Zwischenspeichern von Ausnahmen mit denselben Konstruktoren veranschaulicht, Lazy<T>(Func<T>) finden Sie unter dem-Konstruktor.For an example that demonstrates exception caching using the same constructors, see the Lazy<T>(Func<T>) constructor.

Im Beispiel wird eine LargeObject-Klasse definiert, die durch einen von mehreren Threads verzögert initialisiert wird.The example defines a LargeObject class that will be initialized lazily by one of several threads. Die vier wichtigsten Abschnitte des Codes veranschaulichen die Erstellung des Initialisierers, die Factorymethode, die tatsächliche Initialisierung und den Konstruktor der LargeObject -Klasse, die eine Meldung anzeigt, wenn das Objekt erstellt wird.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. Zu Anfang der Main-Methode wird in diesem Beispiel ein threadsicherer verzögerter Initialisierer für LargeObject erstellt: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)

Die Factorymethode zeigt die Erstellung des Objekts mit einem Platzhalter für die weitere Initialisierung: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

Beachten Sie, dass die ersten beiden Code Abschnitte mit einer Lambda-Funktion kombiniert werden können, wie hier gezeigt: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)

Im Beispiel wird angehalten, um anzugeben, dass ein unbestimmter Zeitraum vergehen kann, bevor eine verzögerte Initialisierung stattfindet.The example pauses, to indicate that an indeterminate period may elapse before lazy initialization occurs. Wenn Sie die Eingabe Taste drücken, werden im Beispiel drei Threads erstellt und gestartet.When you press the Enter key, the example creates and starts three threads. Die ThreadProc -Methode, die von allen drei Threads verwendet wird Value , ruft die-Eigenschaft auf.The ThreadProc method that's used by all three threads calls the Value property. Wenn dies das erste Mal geschieht, LargeObject wird die-Instanz erstellt: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

Der Konstruktor der LargeObject -Klasse, die den letzten Schlüssel Abschnitt des Codes enthält, zeigt eine Meldung an und zeichnet die Identität des Initialisierungs Threads auf.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. Die Ausgabe des Programms wird am Ende der vollständigen Code Auflistung angezeigt.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

Hinweis

Der Einfachheit halber wird in diesem Beispiel eine globale Instanz von Lazy<T> verwendet, und alle Methoden sind 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). Dies sind keine Anforderungen für die Verwendung der verzögerten Initialisierung.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
' 

Hinweise

Verwenden Sie die verzögerte Initialisierung, um die Erstellung eines großen oder ressourcenintensiven Objekts oder die Ausführung einer ressourcenintensiven Aufgabe zu verzögern, insbesondere dann, wenn eine solche Erstellung oder Ausführung während der Lebensdauer des Programms möglicherweise nicht stattfindet.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.

Zum Vorbereiten der verzögerten Initialisierung erstellen Sie eine Instanz von Lazy<T>.To prepare for lazy initialization, you create an instance of Lazy<T>. Das Typargument Lazy<T> des Objekts, das Sie erstellen, gibt den Typ des Objekts an, das Sie verzögert initialisieren möchten.The type argument of the Lazy<T> object that you create specifies the type of the object that you want to initialize lazily. Der Konstruktor, den Sie zum Erstellen des Lazy<T> -Objekts verwenden, bestimmt die Merkmale der Initialisierung.The constructor that you use to create the Lazy<T> object determines the characteristics of the initialization. Die verzögerte Initialisierung tritt beim ersten Zugriff auf die Lazy<T>.Value-Eigenschaft auf.Lazy initialization occurs the first time the Lazy<T>.Value property is accessed.

In den meisten Fällen hängt die Auswahl eines Konstruktors von ihren Antworten auf zwei Fragen ab:In most cases, choosing a constructor depends on your answers to two questions:

  • Ist der Zugriff auf das verzögert initialisierte Objekt von mehreren Threads aus möglich?Will the lazily initialized object be accessed from more than one thread? Wenn dies der Fall Lazy<T> ist, kann das Objekt es in einem beliebigen Thread erstellen.If so, the Lazy<T> object might create it on any thread. Sie können einen der einfachen Konstruktoren verwenden, deren Standardverhalten darin besteht, ein Thread sicheres Lazy<T> Objekt zu erstellen, sodass nur eine Instanz des verzögert instanziierten Objekts erstellt wird, unabhängig davon, wie viele Threads darauf zugreifen.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. Wenn Sie ein Lazy<T> -Objekt erstellen möchten, das nicht Thread sicher ist, müssen Sie einen Konstruktor verwenden, mit dem Sie keine Thread Sicherheit angeben können.To create a Lazy<T> object that is not thread safe, you must use a constructor that enables you to specify no thread safety.

    Achtung

    Wenn das Lazy<T> Objekt Thread sicher ist, wird das verzögert initialisierte Objekt nicht geschützt.Making the Lazy<T> object thread safe does not protect the lazily initialized object. Wenn mehrere Threads auf das verzögert initialisierte Objekt zugreifen können, müssen Sie die Eigenschaften und Methoden für den Multithreadzugriff sicher machen.If multiple threads can access the lazily initialized object, you must make its properties and methods safe for multithreaded access.

  • Erfordert die verzögerte Initialisierung viel Code, oder verfügt das verzögert initialisierte Objekt über einen Parameter losen Konstruktor, der alles benötigt, was Sie benötigen, und löst keine Ausnahmen aus?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? Wenn Sie Initialisierungs Code schreiben müssen, oder wenn Ausnahmen behandelt werden müssen, verwenden Sie einen der-Konstruktoren, der eine Factorymethode annimmt.If you need to write initialization code or if exceptions need to be handled, use one of the constructors that takes a factory method. Schreiben Sie den Initialisierungs Code in der Factorymethode.Write your initialization code in the factory method.

In der folgenden Tabelle wird basierend auf den folgenden beiden Faktoren der zu wählbare Konstruktor angezeigt:The following table shows which constructor to choose, based on these two factors:

Auf das Objekt wird über zugegriffen.Object will be accessed by Wenn kein Initialisierungs Code erforderlich ist (Parameter loser Konstruktor), verwenden SieIf no initialization code is required (parameterless constructor), use Wenn Initialisierungs Code erforderlich ist, verwenden SieIf initialization code is required, use
Mehrere ThreadsMultiple threads Lazy<T>() Lazy<T>(Func<T>)
Ein ThreadOne thread Lazy<T>(Boolean), isThreadSafe wobei auf falsefestgelegt ist.Lazy<T>(Boolean) with isThreadSafe set to false. Lazy<T>(Func<T>, Boolean), isThreadSafe wobei auf falsefestgelegt ist.Lazy<T>(Func<T>, Boolean) with isThreadSafe set to false.

Sie können einen Lambda Ausdruck verwenden, um die Factorymethode anzugeben.You can use a lambda expression to specify the factory method. Dadurch bleibt der gesamte Initialisierungs Code an einem Ort.This keeps all the initialization code in one place. Der Lambda-Ausdruck erfasst den Kontext, einschließlich aller Argumente, die Sie an den Konstruktor des verzögerten initialisierten Objekts übergeben.The lambda expression captures the context, including any arguments you pass to the lazily initialized object's constructor.

Zwischen Speichern von Ausnahmen Wenn Sie Factorymethoden verwenden, werden Ausnahmen zwischengespeichert.Exception caching When you use factory methods, exceptions are cached. Das heißt, wenn die Factorymethode eine Ausnahme auslöst, wenn ein Thread das erste Mal Value versucht, auf Lazy<T> die-Eigenschaft des-Objekts zuzugreifen, wird bei jedem nachfolgenden Versuch dieselbe Ausnahme ausgelöst.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. Dadurch wird sichergestellt, dass alle Value Aufrufe der-Eigenschaft dasselbe Ergebnis erzeugen und kleinere Fehler vermeiden, die auftreten können, wenn verschiedene Threads andere Ergebnisse erhalten.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. Der Lazy<T> steht für einen tatsächlichen T , der andernfalls zu einem früheren Zeitpunkt initialisiert worden wäre, normalerweise während des Starts.The Lazy<T> stands in for an actual T that otherwise would have been initialized at some earlier point, usually during startup. Ein Fehler an diesem früheren Punkt ist normalerweise schwerwiegend.A failure at that earlier point is usually fatal. Wenn eine Möglichkeit für einen BEHEB baren Fehler vorliegt, empfiehlt es sich, die Wiederholungs Logik in der Initialisierungs Routine (in diesem Fall die Factorymethode) zu erstellen, genauso wie bei Verwendung der verzögerten Initialisierung.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.

Alternative zum Sperren In bestimmten Situationen können Sie den Aufwand für das Lazy<T> standardmäßige Sperr Verhalten des Objekts vermeiden.Alternative to locking In certain situations, you might want to avoid the overhead of the Lazy<T> object's default locking behavior. In seltenen Fällen kann es zu Deadlocks kommen.In rare situations, there might be a potential for deadlocks. In solchen Fällen können Sie den-Konstruktor Lazy<T>(Func<T>, LazyThreadSafetyMode) oder den Lazy<T>(LazyThreadSafetyMode) -Konstruktor LazyThreadSafetyMode.PublicationOnlyverwenden und angeben.In such cases, you can use the Lazy<T>(LazyThreadSafetyMode) or Lazy<T>(Func<T>, LazyThreadSafetyMode) constructor, and specify LazyThreadSafetyMode.PublicationOnly. Dies ermöglicht es Lazy<T> dem-Objekt, eine Kopie des verzögert initialisierten Objekts für jeden von mehreren Threads zu erstellen, wenn die Threads Value die-Eigenschaft gleichzeitig aufzurufen.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. Das Lazy<T> -Objekt stellt sicher, dass alle Threads dieselbe Instanz des verzögerten initialisierten Objekts verwenden, und verwirft die nicht verwendeten Instanzen.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. Folglich ist der Aufwand für die Reduzierung des Sperr Aufwands, dass Ihr Programm manchmal zusätzliche Kopien eines teuren Objekts erstellen und verwerfen kann.Thus, the cost of reducing the locking overhead is that your program might sometimes create and discard extra copies of an expensive object. In den meisten Fällen ist dies unwahrscheinlich.In most cases, this is unlikely. Die Beispiele für die Lazy<T>(LazyThreadSafetyMode) - Lazy<T>(Func<T>, LazyThreadSafetyMode) und-Konstruktoren veranschaulichen dieses Verhalten.The examples for the Lazy<T>(LazyThreadSafetyMode) and Lazy<T>(Func<T>, LazyThreadSafetyMode) constructors demonstrate this behavior.

Wichtig

Wenn Sie angeben LazyThreadSafetyMode.PublicationOnly, werden Ausnahmen nie zwischengespeichert, auch wenn Sie eine Factorymethode angeben.When you specify LazyThreadSafetyMode.PublicationOnly, exceptions are never cached, even if you specify a factory method.

Äquivalente Konstruktoren Die LazyThreadSafetyMode.PublicationOnly Lazy<T>(Func<T>, LazyThreadSafetyMode) -und-Konstruktoren können nicht nur die Verwendung von aktivieren, sondern können auch die Funktionalität der anderen Konstruktoren duplizieren. Lazy<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. In der folgenden Tabelle werden die Parameterwerte gezeigt, die ein entsprechendes Verhalten verursachen.The following table shows the parameter values that produce equivalent behavior.

So erstellen Sie Lazy<T> ein-Objekt, dasTo create a Lazy<T> object that is Legen Sie für Konstruktoren mit LazyThreadSafetyMode einem mode -Parameter mode auf fest.For constructors that have a LazyThreadSafetyMode mode parameter, set mode to Legen Sie für Konstruktoren mit einem booleschen isThreadSafe Parameter auf fest. isThreadSafeFor constructors that have a Boolean isThreadSafe parameter, set isThreadSafe to Für Konstruktoren ohne Thread SicherheitsparameterFor constructors with no thread safety parameters
Vollständig Thread sicher; verwendet sperren, um sicherzustellen, dass der Wert nur von einem Thread initialisiert wird.Fully thread safe; uses locking to ensure that only one thread initializes the value. ExecutionAndPublication true Alle derartigen Konstruktoren sind vollständig Thread sicher.All such constructors are fully thread safe.
Nicht Thread sicher.Not thread safe. None false Nicht zutreffend.Not applicable.
Vollständig Thread sicher; Threads können den Wert initialisieren.Fully thread safe; threads race to initialize the value. PublicationOnly Nicht zutreffend.Not applicable. Nicht zutreffend.Not applicable.

Weitere Funktionen Informationen zur Verwendung von Lazy<T> mit Thread statischen Feldern oder als Sicherungs Speicher für Eigenschaften finden Sie unter verzögerte Initialisierung.Other capabilities For information about the use of Lazy<T> with thread-static fields, or as the backing store for properties, see Lazy Initialization.

Konstruktoren

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

Initialisiert eine neue Instanz der Lazy<T>-Klasse.Initializes a new instance of the Lazy<T> class. Wenn eine verzögerte Initialisierung auftritt, wird der parameterlose Konstruktor des Zieltyps verwendet.When lazy initialization occurs, the parameterless constructor of the target type is used.

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

Initialisiert eine neue Instanz der Lazy<T>-Klasse.Initializes a new instance of the Lazy<T> class. Wenn eine verzögerte Initialisierung auftritt, werden der parameterlose Konstruktor des Zieltyps und der angegebene Initialisierungsmodus verwendet.When lazy initialization occurs, the parameterless 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>)

Initialisiert eine neue Instanz der Lazy<T>-Klasse.Initializes a new instance of the Lazy<T> class. Wenn eine verzögerte Initialisierung auftritt, wird die angegebene Initialisierungsfunktion verwendet.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)

Initialisiert eine neue Instanz der Lazy<T>-Klasse.Initializes a new instance of the Lazy<T> class. Wenn eine verzögerte Initialisierung auftritt, werden die angegebene Initialisierungsfunktion und der angegebene Initialisierungsmodus verwendet.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)

Initialisiert eine neue Instanz der Lazy<T>-Klasse, die die angegebene Initialisierungsfunktion und den angegebenen Threadsicherheitsmodus verwendet.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)

Initialisiert eine neue Instanz der Lazy<T>-Klasse, die den parameterlosen Konstruktor von T und den angegebenen Threadsicherheitsmodus verwendet.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) Lazy<T>(T) Lazy<T>(T) Lazy<T>(T)

Initialisiert eine neue Instanz der Lazy<T>-Klasse, die einen vorinitialisierten angegebenen Wert verwendet.Initializes a new instance of the Lazy<T> class that uses a preinitialized specified value.

Eigenschaften

IsValueCreated IsValueCreated IsValueCreated IsValueCreated

Ruft einen Wert ab, der angibt, ob ein Wert für diese Lazy<T>-Instanz erstellt wurde.Gets a value that indicates whether a value has been created for this Lazy<T> instance.

Value Value Value Value

Ruft den verzögert initialisierten Wert der aktuellen Lazy<T>-Instanz ab.Gets the lazily initialized value of the current Lazy<T> instance.

Methoden

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

Bestimmt, ob das angegebene Objekt mit dem aktuellen Objekt identisch ist.Determines whether the specified object is equal to the current object.

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

Fungiert als Standardhashfunktion.Serves as the default hash function.

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

Ruft den Type der aktuellen Instanz ab.Gets the Type of the current instance.

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

Erstellt eine flache Kopie des aktuellen Object.Creates a shallow copy of the current Object.

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

Erstellt eine Zeichenfolgendarstellung der Value-Eigenschaft für diese Instanz und gibt sie zurück.Creates and returns a string representation of the Value property for this instance.

Gilt für:

Threadsicherheit

Standardmäßig sind alle öffentlichen und geschützten Member der Lazy<T> -Klasse Thread sicher und können gleichzeitig von mehreren Threads verwendet werden.By default, all public and protected members of the Lazy<T> class are thread safe and may be used concurrently from multiple threads. Diese Sicherheitsgarantien können optional und pro Instanz entfernt werden, wobei Parameter für die Konstruktoren des Typs verwendet werden.These thread-safety guarantees may be removed optionally and per instance, using parameters to the type's constructors.

Siehe auch