Lazy<T> Klasa

Definicja

Zapewnia obsługę inicjowania z opóźnieniem.Provides support for lazy initialization.

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

Parametry typu

T

Typ obiektu, który jest opóźnieniem zainicjowany.The type of object that is being lazily initialized.

Dziedziczenie
Lazy<T>
Pochodne
Atrybuty

Przykłady

Poniższy przykład ilustruje użycie klasy Lazy<T>, aby zapewnić inicjalizację z opóźnieniem z dostępem z wielu wątków.The following example demonstrates the use of the Lazy<T> class to provide lazy initialization with access from multiple threads.

Uwaga

W przykładzie zastosowano konstruktora Lazy<T>(Func<T>).The example uses the Lazy<T>(Func<T>) constructor. Przedstawiono w nim także użycie konstruktora Lazy<T>(Func<T>, Boolean) (określenie true dla isThreadSafe) i konstruktora Lazy<T>(Func<T>, LazyThreadSafetyMode) (określenie LazyThreadSafetyMode.ExecutionAndPublication dla 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). Aby przełączyć się do innego konstruktora, po prostu zmień konstruktory z komentarzami.To switch to a different constructor, just change which constructors are commented out.

Aby zapoznać się z przykładem, który pokazuje buforowanie wyjątków przy użyciu tych samych konstruktorów, zobacz Konstruktor Lazy<T>(Func<T>).For an example that demonstrates exception caching using the same constructors, see the Lazy<T>(Func<T>) constructor.

W przykładzie zdefiniowano klasę LargeObject, która zostanie zainicjowana opóźnieniem przez jeden z kilku wątków.The example defines a LargeObject class that will be initialized lazily by one of several threads. Cztery kluczowe sekcje kodu ilustrują tworzenie inicjatora, metodę fabryki, rzeczywistą inicjalizację i konstruktora klasy LargeObject, która wyświetla komunikat po utworzeniu obiektu.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. Na początku metody Main przykład tworzy inicjatora z opóźnieniem bezpieczny wątkowo dla 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)

Metoda Factory pokazuje Tworzenie obiektu, z symbolem zastępczym do dalszej inicjalizacji: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

Należy zauważyć, że dwie pierwsze sekcje kodu mogą być połączone przy użyciu funkcji lambda, jak pokazano poniżej: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)

Przykład wstrzymuje się, aby wskazać, że nieokreślony okres może upłynąć przed wystąpieniem inicjalizacji z opóźnieniem.The example pauses, to indicate that an indeterminate period may elapse before lazy initialization occurs. Po naciśnięciu klawisza Enter , przykład tworzy i uruchamia trzy wątki.When you press the Enter key, the example creates and starts three threads. Metoda ThreadProc, która jest używana przez wszystkie trzy wątki wywołuje właściwość Value.The ThreadProc method that's used by all three threads calls the Value property. Po raz pierwszy następuje utworzenie wystąpienia LargeObject:The first time this happens, the LargeObject instance is created:

LargeObject large = lazyLargeObject.Value;

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

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

Konstruktor klasy LargeObject, który zawiera ostatnią sekcję klucza kodu, wyświetla komunikat i rejestruje tożsamość wątku inicjującego.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. Dane wyjściowe z programu pojawiają się na końcu pełnej listy kodu.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

Uwaga

Dla uproszczenia w tym przykładzie użyto globalnego wystąpienia Lazy<T>, a wszystkie metody są static (Shared w Visual Basic).For simplicity, this example uses a global instance of Lazy<T>, and all the methods are static (Shared in Visual Basic). Nie są wymogi, od których zależy możliwość inicjowania z opóźnieniem.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
' 

Uwagi

Użyj inicjowania z opóźnieniem, aby odroczyć Tworzenie obiektu dużego lub intensywnie korzystających z zasobów, lub wykonać zadanie intensywnie korzystające z zasobów, szczególnie w przypadku, gdy takie utworzenie lub wykonanie może nie nastąpić w okresie istnienia programu.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.

Aby przygotować się do inicjowania z opóźnieniem, należy utworzyć wystąpienie Lazy<T>.To prepare for lazy initialization, you create an instance of Lazy<T>. Typ argumentu tworzonego obiektu Lazy<T> określa typ obiektu, który chcesz zainicjować opóźnieniem.The type argument of the Lazy<T> object that you create specifies the type of the object that you want to initialize lazily. Konstruktor używany do tworzenia obiektu Lazy<T> określa charakterystykę inicjalizacji.The constructor that you use to create the Lazy<T> object determines the characteristics of the initialization. Inicjalizacja z opóźnieniem następuje podczas pierwszego dostępu do właściwości Lazy<T>.Value.Lazy initialization occurs the first time the Lazy<T>.Value property is accessed.

W większości przypadków wybór konstruktora zależy od odpowiedzi na dwa pytania:In most cases, choosing a constructor depends on your answers to two questions:

  • Czy dostęp do zainicjowanego obiektu opóźnieniem będzie możliwy z więcej niż jednego wątku?Will the lazily initialized object be accessed from more than one thread? Jeśli tak, obiekt Lazy<T> może utworzyć go na dowolnym wątku.If so, the Lazy<T> object might create it on any thread. Można użyć jednego z prostych konstruktorów, których domyślnym zachowaniem jest utworzenie obiektu Lazy<T> bezpiecznego dla wątków, tak aby tylko jedno wystąpienie obiektu opóźnieniem wystąpienie jest tworzone bez względu na to, ile wątków próbuje uzyskać do niego dostęp.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. Aby utworzyć obiekt Lazy<T>, który nie jest bezpieczny dla wątków, należy użyć konstruktora, który umożliwia określenie braku bezpieczeństwa wątku.To create a Lazy<T> object that is not thread safe, you must use a constructor that enables you to specify no thread safety.

    Przestroga

    Lazy<T> bezpieczny wątek obiektu nie chroni obiektu zainicjowany opóźnieniem.Making the Lazy<T> object thread safe does not protect the lazily initialized object. Jeśli wiele wątków może uzyskać dostęp do zainicjowanego obiektu opóźnieniem, należy wykonać jego właściwości i metody bezpiecznie dla wielowątkowego dostępu.If multiple threads can access the lazily initialized object, you must make its properties and methods safe for multithreaded access.

  • Czy Inicjalizacja z opóźnieniem wymaga dużej ilości kodu lub czy obiekt zainicjowany opóźnieniem ma Konstruktor bez parametrów, który robi wszystko, czego potrzebujesz, i nie zgłasza wyjątków?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? Jeśli musisz napisać kod inicjujący lub jeśli trzeba obsługiwać wyjątki, użyj jednego z konstruktorów przyjmujących metodę fabryki.If you need to write initialization code or if exceptions need to be handled, use one of the constructors that takes a factory method. Napisz kod inicjujący w metodzie fabryki.Write your initialization code in the factory method.

W poniższej tabeli przedstawiono Konstruktor, który należy wybrać, w oparciu o te dwa czynniki:The following table shows which constructor to choose, based on these two factors:

Dostęp do obiektu zostanie uzyskany przezObject will be accessed by Jeśli kod inicjalizacji nie jest wymagany (Konstruktor bez parametrów), użyjIf no initialization code is required (parameterless constructor), use Jeśli jest wymagany kod inicjujący, użyjIf initialization code is required, use
Wiele wątkówMultiple threads Lazy<T>() Lazy<T>(Func<T>)
Jeden wątekOne thread Lazy<T>(Boolean) z isThreadSafeem ustawionym na false.Lazy<T>(Boolean) with isThreadSafe set to false. Lazy<T>(Func<T>, Boolean) z isThreadSafeem ustawionym na false.Lazy<T>(Func<T>, Boolean) with isThreadSafe set to false.

Aby określić metodę fabryki, można użyć wyrażenia lambda.You can use a lambda expression to specify the factory method. Dzięki temu cały kod inicjalizacji jest zachowywany w jednym miejscu.This keeps all the initialization code in one place. Wyrażenie lambda przechwytuje kontekst, łącznie z dowolnymi argumentami przekazywanymi do konstruktora obiektu zainicjowane przez opóźnieniem.The lambda expression captures the context, including any arguments you pass to the lazily initialized object's constructor.

Buforowanie wyjątków W przypadku korzystania z metod fabrycznych wyjątki są buforowane.Exception caching When you use factory methods, exceptions are cached. Oznacza to, że jeśli metoda fabryki zgłasza wyjątek, gdy po raz pierwszy wątek próbuje uzyskać dostęp do właściwości Value obiektu Lazy<T>, ten sam wyjątek jest zgłaszany przy każdej kolejnej próbie.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. Zapewnia to, że każde wywołanie właściwości Value daje ten sam wynik i pozwala uniknąć niewielkich błędów, które mogą wystąpić, jeśli różne wątki będą uzyskiwać różne wyniki.This ensures that every call to the Value property produces the same result and avoids subtle errors that might arise if different threads get different results. Lazy<T> oznacza rzeczywiste T, które w przeciwnym razie zostałyby zainicjowane w pewnym wcześniejszym momencie, zazwyczaj podczas uruchamiania.The Lazy<T> stands in for an actual T that otherwise would have been initialized at some earlier point, usually during startup. Niepowodzenie w tym wcześniejszym punkcie jest zwykle krytyczne.A failure at that earlier point is usually fatal. Jeśli istnieje możliwość potencjalnego błędu, zalecamy utworzenie logiki ponawiania w procedurze inicjowania (w tym przypadku metody fabryki), podobnie jak w przypadku inicjalizacji z opóźnieniem.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.

Alternatywa do blokowania W niektórych sytuacjach może być konieczne uniknięcie obciążenia domyślnego zachowania blokowania obiektu Lazy<T>.Alternative to locking In certain situations, you might want to avoid the overhead of the Lazy<T> object's default locking behavior. W rzadkich przypadkach może istnieć potencjalne zakleszczenie.In rare situations, there might be a potential for deadlocks. W takich przypadkach można użyć konstruktora Lazy<T>(LazyThreadSafetyMode) lub Lazy<T>(Func<T>, LazyThreadSafetyMode) i określić LazyThreadSafetyMode.PublicationOnly.In such cases, you can use the Lazy<T>(LazyThreadSafetyMode) or Lazy<T>(Func<T>, LazyThreadSafetyMode) constructor, and specify LazyThreadSafetyMode.PublicationOnly. Dzięki temu obiekt Lazy<T> może utworzyć kopię zainicjowanego obiektu opóźnieniem w każdym z kilku wątków, jeśli wątki wywołują Właściwość Value jednocześnie.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. Obiekt Lazy<T> gwarantuje, że wszystkie wątki używają tego samego wystąpienia opóźnieniem obiektu zainicjowany i odrzuca wystąpienia, które nie są używane.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. W ten sposób koszt zmniejszenia obciążenia polega na tym, że program może czasami tworzyć i odrzucać dodatkowe kopie kosztownego obiektu.Thus, the cost of reducing the locking overhead is that your program might sometimes create and discard extra copies of an expensive object. W większości przypadków jest to mało prawdopodobne.In most cases, this is unlikely. Przykłady dla konstruktorów Lazy<T>(LazyThreadSafetyMode) i Lazy<T>(Func<T>, LazyThreadSafetyMode) przedstawiają takie zachowanie.The examples for the Lazy<T>(LazyThreadSafetyMode) and Lazy<T>(Func<T>, LazyThreadSafetyMode) constructors demonstrate this behavior.

Ważne

W przypadku określenia LazyThreadSafetyMode.PublicationOnlywyjątki nigdy nie są buforowane, nawet w przypadku określenia metody fabryki.When you specify LazyThreadSafetyMode.PublicationOnly, exceptions are never cached, even if you specify a factory method.

Równoważne konstruktory Oprócz umożliwienia używania LazyThreadSafetyMode.PublicationOnlykonstruktory Lazy<T>(LazyThreadSafetyMode) i Lazy<T>(Func<T>, LazyThreadSafetyMode) mogą duplikować funkcjonalność innych konstruktorów.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. W poniższej tabeli przedstawiono wartości parametrów, które generują równoważne zachowanie.The following table shows the parameter values that produce equivalent behavior.

Aby utworzyć obiekt Lazy<T>, który jestTo create a Lazy<T> object that is Dla konstruktorów, które mają parametr mode LazyThreadSafetyMode, ustaw mode naFor constructors that have a LazyThreadSafetyMode mode parameter, set mode to Dla konstruktorów, które mają parametr Boolean isThreadSafe, ustaw isThreadSafe naFor constructors that have a Boolean isThreadSafe parameter, set isThreadSafe to Dla konstruktorów bez parametrów bezpieczeństwa wątkówFor constructors with no thread safety parameters
W pełni bezpieczne wątki; używa blokowania, aby upewnić się, że tylko jeden wątek inicjuje wartość.Fully thread safe; uses locking to ensure that only one thread initializes the value. ExecutionAndPublication true Wszystkie takie konstruktory są w pełni bezpieczne wątkowo.All such constructors are fully thread safe.
Nie jest bezpieczny wątkowo.Not thread safe. None false Nie dotyczy.Not applicable.
W pełni bezpieczne wątki; możliwość zainicjowania wartości przez rasę wątków.Fully thread safe; threads race to initialize the value. PublicationOnly Nie dotyczy.Not applicable. Nie dotyczy.Not applicable.

Inne możliwości Aby uzyskać informacje na temat używania Lazy<T> z polami statycznymi wątków lub jako magazyn zapasowy dla właściwości, zobacz Inicjalizacja z opóźnieniem.Other capabilities For information about the use of Lazy<T> with thread-static fields, or as the backing store for properties, see Lazy Initialization.

Konstruktory

Lazy<T>()

Inicjuje nowe wystąpienie klasy Lazy<T>.Initializes a new instance of the Lazy<T> class. Gdy następuje Inicjalizacja z opóźnieniem, jest używany Konstruktor bez parametrów typu docelowego.When lazy initialization occurs, the parameterless constructor of the target type is used.

Lazy<T>(Boolean)

Inicjuje nowe wystąpienie klasy Lazy<T>.Initializes a new instance of the Lazy<T> class. Gdy następuje Inicjalizacja z opóźnieniem, używany jest Konstruktor bez parametrów typu docelowego i określonego trybu inicjalizacji.When lazy initialization occurs, the parameterless constructor of the target type and the specified initialization mode are used.

Lazy<T>(Func<T>)

Inicjuje nowe wystąpienie klasy Lazy<T>.Initializes a new instance of the Lazy<T> class. Gdy następuje Inicjalizacja z opóźnieniem, używana jest określona funkcja inicjująca.When lazy initialization occurs, the specified initialization function is used.

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

Inicjuje nowe wystąpienie klasy Lazy<T>.Initializes a new instance of the Lazy<T> class. Gdy następuje Inicjalizacja z opóźnieniem, używana jest określona funkcja inicjująca i tryb inicjalizacji.When lazy initialization occurs, the specified initialization function and initialization mode are used.

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

Inicjuje nowe wystąpienie klasy Lazy<T>, która używa określonej funkcji inicjującej i trybu ochrony wątku.Initializes a new instance of the Lazy<T> class that uses the specified initialization function and thread-safety mode.

Lazy<T>(LazyThreadSafetyMode)

Inicjuje nowe wystąpienie klasy Lazy<T>, która używa konstruktora bez parametrów T i określonego trybu ochrony wątku.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)

Inicjuje nowe wystąpienie klasy Lazy<T>, która używa wstępnie zainicjowanej określonej wartości.Initializes a new instance of the Lazy<T> class that uses a preinitialized specified value.

Właściwości

IsValueCreated

Pobiera wartość wskazującą, czy dla tego wystąpienia Lazy<T> została utworzona wartość.Gets a value that indicates whether a value has been created for this Lazy<T> instance.

Value

Pobiera wartość zainicjowaną przez opóźnieniem dla bieżącego wystąpienia Lazy<T>.Gets the lazily initialized value of the current Lazy<T> instance.

Metody

Equals(Object)

Określa, czy dany obiekt jest taki sam, jak bieżący obiekt.Determines whether the specified object is equal to the current object.

(Odziedziczone po Object)
GetHashCode()

Służy jako domyślna funkcja skrótu.Serves as the default hash function.

(Odziedziczone po Object)
GetType()

Pobiera Type bieżącego wystąpienia.Gets the Type of the current instance.

(Odziedziczone po Object)
MemberwiseClone()

Tworzy skróconą kopię bieżącego Object.Creates a shallow copy of the current Object.

(Odziedziczone po Object)
ToString()

Tworzy i zwraca reprezentację ciągu Value dla tego wystąpienia.Creates and returns a string representation of the Value property for this instance.

Dotyczy

Bezpieczeństwo wątkowe

Domyślnie wszystkie publiczne i chronione elementy członkowskie klasy Lazy<T> są bezpieczne dla wątków i mogą być używane współbieżnie z wielu wątków.By default, all public and protected members of the Lazy<T> class are thread safe and may be used concurrently from multiple threads. Te gwarancje bezpieczeństwa wątków mogą zostać usunięte opcjonalnie i na każde wystąpienie, przy użyciu parametrów do konstruktorów typu.These thread-safety guarantees may be removed optionally and per instance, using parameters to the type's constructors.

Zobacz też