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
[<System.Runtime.InteropServices.ComVisible(false)>]
[<System.Serializable>]
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 demonstruje użycie Lazy<T> klasy w celu zapewnienia inicjalizacji 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 Lazy<T>(Func<T>) konstruktora.The example uses the Lazy<T>(Func<T>) constructor. Ilustruje także użycie Lazy<T>(Func<T>, Boolean) konstruktora (określenie true dla isThreadSafe ) i Lazy<T>(Func<T>, LazyThreadSafetyMode) konstruktora (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.

Przykład demonstrujący buforowanie wyjątków przy użyciu tych samych konstruktorów można znaleźć w Lazy<T>(Func<T>) konstruktorze.For an example that demonstrates exception caching using the same constructors, see the Lazy<T>(Func<T>) constructor.

W przykładzie zdefiniowano LargeObject klasę, 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 LargeObject klasy, 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 Main metody 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. ThreadProcMetoda, która jest używana przez wszystkie trzy wątki wywołuje Value Właściwość.The ThreadProc method that's used by all three threads calls the Value property. Po raz pierwszy następuje LargeObject utworzenie wystąpienia: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 LargeObject klasy, 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 wystąpienia globalnego Lazy<T> i 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 Lazy<T> tworzonego obiektu określa typ obiektu, który ma zostać zainicjowany 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 Lazy<T> obiektu określa charakterystykę inicjalizacji.The constructor that you use to create the Lazy<T> object determines the characteristics of the initialization. Podczas pierwszego uzyskiwania dostępu do właściwości następuje Inicjalizacja z opóźnieniem 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, Lazy<T> obiekt 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 bezpiecznego wątkowego Lazy<T> , 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ć Lazy<T> obiekt, który nie jest bezpieczny dla wątków, należy użyć konstruktora, który umożliwia określenie braku bezpieczeństwa wątków.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

    Sprawianie, że Lazy<T> wątek obiektu bezpieczny nie chroni obiektu opóźnieniem zainicjowany.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 isThreadSafe ustawioną na false .Lazy<T>(Boolean) with isThreadSafe set to false. Lazy<T>(Func<T>, Boolean) z isThreadSafe ustawioną 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 podczas pierwszego wątku próbuje uzyskać dostęp do Value właściwości Lazy<T> obiektu, 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. Gwarantuje to, że każde wywołanie Value Właściwości 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. Jest to wartość Lazy<T> rzeczywista, T która w przeciwnym razie mogłaby zostać zainicjowana 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 Lazy<T> domyślnego zachowania blokowania obiektu.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ć Lazy<T>(LazyThreadSafetyMode) Lazy<T>(Func<T>, LazyThreadSafetyMode) konstruktora or 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 Lazy<T> obiekt może utworzyć kopię zainicjowanego obiektu opóźnieniem w każdym z kilku wątków, jeśli wątki wywołują Value Właściwość 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. Lazy<T>Obiekt 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 Lazy<T>(LazyThreadSafetyMode) Lazy<T>(Func<T>, LazyThreadSafetyMode) konstruktorów i 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.PublicationOnly wyjątków 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 Poza umożliwieniem korzystania z programu LazyThreadSafetyMode.PublicationOnly , Lazy<T>(LazyThreadSafetyMode) Lazy<T>(Func<T>, LazyThreadSafetyMode) konstruktory i 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ć Lazy<T> obiekt, który jestTo create a Lazy<T> object that is Dla konstruktorów, które mają LazyThreadSafetyMode mode parametr, ustaw mode naFor constructors that have a LazyThreadSafetyMode mode parameter, set mode to Dla konstruktorów, które mają isThreadSafe parametr Boolean, ustaw wartość 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 dotyczące używania programu 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 Lazy<T> klasy, 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 Lazy<T> klasy, 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 Lazy<T> klasy, 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 została utworzona wartość Lazy<T> .Gets a value that indicates whether a value has been created for this Lazy<T> instance.

Value

Pobiera wartość zainicjowaną przez opóźnieniem w bieżącym Lazy<T> wystąpieniu.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żące wystąpienie.Gets the Type of the current instance.

(Odziedziczone po Object)
MemberwiseClone()

Tworzy skróconą kopię bieżącego elementu 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 składowe Lazy<T> klasy są bezpieczne wątkowo 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ż