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

Definition

Stellt Unterstützung für die verzögerte Initialisierung bereit. 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 Typ des Objekts, das 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

Das folgende Beispiel zeigt die Verwendung der Lazy<T> Klasse, um verzögerte Initialisierung, beim 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 die Lazy<T>(Func<T>) Konstruktor.The example uses the Lazy<T>(Func<T>) constructor. Es zeigt auch die Verwendung von der Lazy<T>(Func<T>, Boolean) Konstruktor (Angeben von true für isThreadSafe) und die Lazy<T>(Func<T>, LazyThreadSafetyMode) Konstruktor (angeben LazyThreadSafetyMode.ExecutionAndPublication für 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). Um in einen anderen Konstruktor wechseln, ändern Sie einfach die Konstruktoren auskommentiert werden.To switch to a different constructor, just change which constructors are commented out.

Ein Beispiel für die Ausnahme mithilfe der gleichen Konstruktoren, finden Sie unter den Lazy<T>(Func<T>) 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 der Initialisierer, die Factorymethode, die eigentliche Initialisierung und den Konstruktor der LargeObject -Klasse, die eine Meldung angezeigt, 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<LargeObject>(InitLargeObject, true);
'lazyLargeObject = new Lazy<LargeObject>(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 Codeabschnitten mithilfe einer Lambdafunktion 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 für ein unbestimmter Zeitraum abläuft, bevor die verzögerte Initialisierung auftritt.The example pauses, to indicate that an indeterminate period may elapse before lazy initialization occurs. Beim Drücken der EINGABETASTE Schlüssel, das Beispiel erstellt und startet drei Threads.When you press the Enter key, the example creates and starts three threads. Die ThreadProc -Methode, die durch Aufrufe für alle drei Threads verwendet, wird die Value Eigenschaft.The ThreadProc method that's used by all three threads calls the Value property. Beim ersten in diesem Fall die LargeObject Instanz erstellt wird: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 die LargeObject -Klasse, die wichtigsten letzten Abschnitt des Codes enthält, wird eine Meldung angezeigt, und zeichnet die Identität des Threads wird initialisiert.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. Am Ende das vollständige Codebeispiel wird die Ausgabe des Programms 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
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
' 

Hinweise

Verwenden Sie verzögerten Initialisierung, um die Erstellung einer großen oder ressourcenintensiven-Objekts, oder die Ausführung einer Aufgabe mit großem Ressourcenaufwand verzögern, insbesondere dann, wenn eine solche erstellen oder die Ausführung nicht während der Lebensdauer des Programms auftreten kann.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.

Zur Vorbereitung der verzögerten Initialisierung, die Sie erstellen eine Instanz des Lazy<T>.To prepare for lazy initialization, you create an instance of Lazy<T>. Das Typargument, der die Lazy<T> -Objekt, das Sie erstellen, gibt den Typ des Objekts, das verzögert initialisiert werden soll.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, mit denen Sie erstellen die Lazy<T> Objekts bestimmen die Eigenschaften 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 Antworten auf zwei Fragen einen Konstruktor auswählen:In most cases, choosing a constructor depends on your answers to two questions:

  • Wird die verzögert initialisierte Objekt von mehreren Threads werden zugegriffen?Will the lazily initialized object be accessed from more than one thread? Wenn dies der Fall ist, die Lazy<T> Objekt können sie auf einem beliebigen Thread erstellen.If so, the Lazy<T> object might create it on any thread. Können Sie eines einfachen Konstruktors, deren Standardverhalten ist, erstellen Sie eine threadsichere Lazy<T> Objekt, so dass nur eine Instanz des verzögert instanziierten Objekts erstellt wird, unabhängig davon, wie viele Threads versuchen, darauf zuzugreifen.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. Zum Erstellen einer Lazy<T> Objekt, das nicht threadsicher ist, müssen Sie einen Konstruktor, der Ihnen ermöglicht, geben Sie keine Threadsicherheit verwenden.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

    Wodurch die Lazy<T> Objekt threadsicher bietet keinen Schutz für die verzögert initialisierte Objekt.Making the Lazy<T> object thread safe does not protect the lazily initialized object. Wenn mehrere Threads, die verzögert initialisierte Objekt zugreifen können, müssen Sie die Eigenschaften und Methoden für Speicherzugriffs in Multithreadanwendungen.If multiple threads can access the lazily initialized object, you must make its properties and methods safe for multithreaded access.

  • Erfordert verzögerter Initialisierung viel Code, oder verfügt das verzögert initialisierte Objekt über einen Standardkonstruktor, die alles, 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 default constructor that does everything you need and doesn't throw exceptions? Verwenden Sie Wenn Sie Code zum Initialisieren der schreiben müssen oder Ausnahmen behandelt werden müssen, einen der Konstruktoren, die eine Factorymethode verwendet.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 Initialisierungscode in der Factorymethode.Write your initialization code in the factory method.

Die folgende Tabelle zeigt die Konstruktor auf, basierend auf diesen zwei Faktoren:The following table shows which constructor to choose, based on these two factors:

Objekt wird vom zugegriffen werdenObject will be accessed by Wenn kein Code für die Initialisierung erforderlich ist (Standard-Konstruktor) verwendenIf no initialization code is required (default constructor), use Wenn der Code für die Initialisierung erforderlich ist, verwendenIf initialization code is required, use
Mehrere threadsMultiple threads Lazy<T>() Lazy<T>(Func<T>)
Ein threadOne thread Lazy<T>(Boolean) mit isThreadSafe festgelegt false.Lazy<T>(Boolean) with isThreadSafe set to false. Lazy<T>(Func<T>, Boolean) mit isThreadSafe festgelegt false.Lazy<T>(Func<T>, Boolean) with isThreadSafe set to false.

Sie können einen Lambda-Ausdruck verwenden, an die Factorymethode.You can use a lambda expression to specify the factory method. Auf diese Weise die gesamte Initialisierungscode in einem zentralen Ort.This keeps all the initialization code in one place. Der Lambda-Ausdruck erfasst den Kontext, einschließlich von Argumenten, die Sie an den verzögert initialisierten Konstruktor des Objekts übergeben.The lambda expression captures the context, including any arguments you pass to the lazily initialized object's constructor.

Zwischenspeichern von Ausnahmen bei Verwendung von Factorymethoden Ausnahmen werden zwischengespeichert.Exception caching When you use factory methods, exceptions are cached. D.h., wenn die Factory-Methode löst eine Ausnahme beim ersten Mal aus, ein Thread versucht, Zugriff auf die Value Eigenschaft der Lazy<T> Objekt ist, wird die gleiche Ausnahme wird bei jedem nachfolgenden Versuch 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 für jeden Aufruf der Value Eigenschaft führt zum gleichen Ergebnis, und vermeidet Fehler auftreten, die auftreten können, wenn unterschiedliche Threads verschiedene Ergebnisse zu 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. Die Lazy<T> stellvertretend für eine tatsächliche T , andernfalls würde initialisiert wurden zu einem früheren Zeitpunkt, in der Regel 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. An diesem Punkt früheren ist in der Regel Schwerwiegender.A failure at that earlier point is usually fatal. Wenn es besteht die Gefahr für eine wiederherstellbare Fehler, empfehlen wir, dass Sie die Wiederholungslogik in der Initialisierungsroutine (in diesem Fall die Factorymethode), integrieren, wie wenn Sie die verzögerten Initialisierung verwenden würden.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 möchten Sie möglicherweise den Mehraufwand zu vermeiden der Lazy<T> des Objekts Standard Sperrverhaltens.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 liegt möglicherweise ein Potenzial für Deadlocks.In rare situations, there might be a potential for deadlocks. In solchen Fällen können Sie die Lazy<T>(LazyThreadSafetyMode) oder Lazy<T>(Func<T>, LazyThreadSafetyMode) -Konstruktor, und geben Sie LazyThreadSafetyMode.PublicationOnly.In such cases, you can use the Lazy<T>(LazyThreadSafetyMode) or Lazy<T>(Func<T>, LazyThreadSafetyMode) constructor, and specify LazyThreadSafetyMode.PublicationOnly. Dies ermöglicht die Lazy<T> Objekt, das eine Kopie des Objekts verzögert initialisierte auf jedem von mehreren Threads zu erstellen, wenn die Threads rufen die Value Eigenschaft gleichzeitig.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. Die Lazy<T> Objekt wird sichergestellt, dass alle Threads dieselbe Instanz des Objekts verzögert initialisierte und verwirft die Instanzen, die nicht verwendet werden.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. Daher ist die Kosten der Aufwand für Sperren zu reduzieren, dass das Programm möglicherweise manchmal erstellen und zusätzliche Kopien ein teures Objekt zu verwerfen.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 wahrscheinlich nicht.In most cases, this is unlikely. Die Beispiele für die Lazy<T>(LazyThreadSafetyMode) und Lazy<T>(Func<T>, LazyThreadSafetyMode) Konstruktoren wird dieses Verhalten demonstriert.The examples for the Lazy<T>(LazyThreadSafetyMode) and Lazy<T>(Func<T>, LazyThreadSafetyMode) constructors demonstrate this behavior.

Wichtig

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

Entsprechende Konstruktoren zusätzlich zum Aktivieren der Verwendung von LazyThreadSafetyMode.PublicationOnly, Lazy<T>(LazyThreadSafetyMode) und Lazy<T>(Func<T>, LazyThreadSafetyMode) Konstruktoren können die Funktionalität von den anderen Konstruktoren duplizieren.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. Die folgende Tabelle zeigt die Werte der Parameter, die entsprechende Verhalten zu erzeugen.The following table shows the parameter values that produce equivalent behavior.

Zum Erstellen einer Lazy<T> -Standardobjekt abTo create a Lazy<T> object that is Für Konstruktoren, die eine LazyThreadSafetyMode mode Parametersatz, mode aufFor constructors that have a LazyThreadSafetyMode mode parameter, set mode to Für Konstruktoren, die einen booleschen Wert haben isThreadSafe Parametersatz, isThreadSafe aufFor constructors that have a Boolean isThreadSafe parameter, set isThreadSafe to Für Konstruktoren mit keine ThreadsicherheitsparameterFor constructors with no thread safety parameters
Vollständig threadsicher; verwendet sperren, um sicherzustellen, dass nur ein Thread auf den Wert initialisiert.Fully thread safe; uses locking to ensure that only one thread initializes the value. ExecutionAndPublication true Alle diese Konstruktoren sind vollständig threadsicher.All such constructors are fully thread safe.
Nicht threadsicher.Not thread safe. None false Nicht zutreffend.Not applicable.
Vollständig threadsicher; Threads Rennen um den Wert zu initialisieren.Fully thread safe; threads race to initialize the value. PublicationOnly Nicht zutreffend.Not applicable. Nicht zutreffend.Not applicable.

Andere Funktionen Informationen zur Verwendung von Lazy<T> mit threadstatische Felder oder als Sicherungsspeicher 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 Standardkonstruktor des Zieltyps verwendet. 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)

Initialisiert eine neue Instanz der Lazy<T>-Klasse. Initializes a new instance of the Lazy<T> class. Bei einer verzögerten Initialisierung werden der Standardkonstruktor des Zieltyps und der angegebene Initialisierungsmodus verwendet. 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>)

Initialisiert eine neue Instanz der Lazy<T>-Klasse. Initializes a new instance of the Lazy<T> class. Bei einer verzögerten Initialisierung 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. Bei einer verzögerten Initialisierung 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 Standardkonstruktor von T und den angegebenen Threadsicherheitsmodus verwendet. 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)

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 die 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 diese zurück. Creates and returns a string representation of the Value property for this instance.

Gilt für:

Threadsicherheit

Standardmäßig werden alle öffentlichen und geschützten Member, der die Lazy<T> Klasse sind threadsicher und können von mehreren Threads gleichzeitig 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 Garantien für Threadsicherheit können optional und pro Instanz, die mit Parametern für den Konstruktoren des Typs entfernt werden. These thread-safety guarantees may be removed optionally and per instance, using parameters to the type's constructors.

Siehe auch