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

Définition

Fournit une prise en charge des initialisations tardives.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)

Paramètres de type

T

Type d'objet initialisé de façon tardive.The type of object that is being lazily initialized.

Héritage
Lazy<T>Lazy<T>Lazy<T>Lazy<T>
Dérivé
Attributs

Exemples

L’exemple suivant illustre l’utilisation de la Lazy<T> classe pour fournir l’initialisation tardive avec accès à partir de plusieurs threads.The following example demonstrates the use of the Lazy<T> class to provide lazy initialization with access from multiple threads.

Notes

L’exemple utilise le Lazy<T>(Func<T>) constructeur.The example uses the Lazy<T>(Func<T>) constructor. Il illustre également l’utilisation de la Lazy<T>(Func<T>, Boolean) constructeur (spécifiant true pour isThreadSafe) et le Lazy<T>(Func<T>, LazyThreadSafetyMode) constructeur (spécifiant LazyThreadSafetyMode.ExecutionAndPublication pour 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). Pour basculer vers un autre constructeur, modifiez simplement les constructeurs sont commentées.To switch to a different constructor, just change which constructors are commented out.

Pour obtenir un exemple qui illustre l’exception, la mise en cache à l’aide des constructeurs de mêmes, consultez le Lazy<T>(Func<T>) constructeur.For an example that demonstrates exception caching using the same constructors, see the Lazy<T>(Func<T>) constructor.

L'exemple définit une classe LargeObject qui sera initialisée tardivement par l'un des nombreux threads.The example defines a LargeObject class that will be initialized lazily by one of several threads. Les quatre principales sections de code illustrent la création de l’initialiseur, la méthode de fabrique, l’initialisation réelle et le constructeur de la LargeObject (classe), qui affiche un message lorsque l’objet est créé.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. Au début de la méthode Main, l'exemple crée l'initialiseur de type lazy thread-safe pour LargeObject :At the beginning of the Main method, the example creates the thread-safe lazy initializer for LargeObject:

lazyLargeObject = new Lazy<LargeObject>(InitLargeObject);

// The following lines show how to use other constructors to achieve exactly the
// same result as the previous line: 
//lazyLargeObject = new Lazy<LargeObject>(InitLargeObject, true);
//lazyLargeObject = new Lazy<LargeObject>(InitLargeObject, 
//                               LazyThreadSafetyMode.ExecutionAndPublication);
lazyLargeObject = New Lazy(Of LargeObject)(AddressOf InitLargeObject)

' The following lines show how to use other constructors to achieve exactly the
' same result as the previous line: 
'lazyLargeObject = new Lazy<LargeObject>(InitLargeObject, true);
'lazyLargeObject = new Lazy<LargeObject>(InitLargeObject, _
'                               LazyThreadSafetyMode.ExecutionAndPublication);

La méthode de fabrique illustre la création de l’objet, avec un espace réservé pour une initialisation supplémentaire :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

Notez que les sections de code tout d’abord deux peuvent être combinées à l’aide d’une fonction lambda, comme illustré ici :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)

L’exemple met en pause, pour indiquer qu’une période indéterminée peut-être s’écouler avant l’initialisation tardive se produit.The example pauses, to indicate that an indeterminate period may elapse before lazy initialization occurs. Quand vous appuyez sur la entrée clé, l’exemple crée et démarre trois threads.When you press the Enter key, the example creates and starts three threads. Le ThreadProc méthode qui est utilisée par tous les appels de trois threads le Value propriété.The ThreadProc method that's used by all three threads calls the Value property. La première fois dans ce cas, le LargeObject instance est créée :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

Le constructeur de la LargeObject (classe), qui inclut la dernière section clée du code, affiche un message et enregistre l’identité du thread lors de l’initialisation.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. La sortie du programme s’affiche à la fin de la liste de code complet.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

Notes

Pour plus de simplicité, cet exemple utilise une instance globale de Lazy<T> et toutes les méthodes sont static (Shared en Visual Basic).For simplicity, this example uses a global instance of Lazy<T>, and all the methods are static (Shared in Visual Basic). Ce ne sont pas des exigences pour l’utilisation de l’initialisation tardive.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
' 

Remarques

Utilisez l’initialisation tardive pour différer la création d’un objet volumineux ou gourmandes en ressources ou l’exécution d’une tâche gourmande en ressources, en particulier lorsqu’une telle création ou exécution ne peut pas se produire pendant la durée de vie du programme.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.

Pour préparer l’initialisation tardive, vous créez une instance de Lazy<T>.To prepare for lazy initialization, you create an instance of Lazy<T>. L’argument de type de la Lazy<T> objet que vous créez Spécifie le type de l’objet que vous souhaitez initialiser tardivement.The type argument of the Lazy<T> object that you create specifies the type of the object that you want to initialize lazily. Le constructeur qui vous permet de créer le Lazy<T> objet détermine les caractéristiques de l’initialisation.The constructor that you use to create the Lazy<T> object determines the characteristics of the initialization. L’initialisation tardive se produit lors du premier accès à la propriété Lazy<T>.Value.Lazy initialization occurs the first time the Lazy<T>.Value property is accessed.

Dans la plupart des cas, en choisissant un constructeur dépend de vos réponses aux deux questions :In most cases, choosing a constructor depends on your answers to two questions:

  • L’objet initialisé tardivement est accessible à partir de plusieurs threads ?Will the lazily initialized object be accessed from more than one thread? Dans ce cas, le Lazy<T> objet peut créer le certificat sur n’importe quel thread.If so, the Lazy<T> object might create it on any thread. Vous pouvez utiliser un des constructeurs simples dont le comportement par défaut consiste à créer un thread-safe Lazy<T> de l’objet, afin que seule une instance de l’objet instancié de manière différée est créée, quel que soit le nombre de threads essayez d’y accéder.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. Pour créer un Lazy<T> objet qui n’est pas thread-safe, vous devez utiliser un constructeur qui vous permet de spécifier aucune sécurité des threads.To create a Lazy<T> object that is not thread safe, you must use a constructor that enables you to specify no thread safety.

    Attention

    Rendre le Lazy<T> objet thread-safe ne protège pas l’objet initialisé tardivement.Making the Lazy<T> object thread safe does not protect the lazily initialized object. Si plusieurs threads peuvent accéder à l’objet initialisé tardivement, vous devez apporter ses propriétés et méthodes sécurisés pour l’accès multithread.If multiple threads can access the lazily initialized object, you must make its properties and methods safe for multithreaded access.

  • Initialisation tardive nécessite-t-il une grande quantité de code, ou l’objet initialisé tardivement ont un constructeur par défaut qui effectue tout ce dont vous avez besoin et ne lèvent des exceptions ?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? Si vous avez besoin d’écrire du code d’initialisation ou si les exceptions doivent être traitées, utilisez un des constructeurs qui prend une méthode de fabrique.If you need to write initialization code or if exceptions need to be handled, use one of the constructors that takes a factory method. Écrire votre code d’initialisation dans la méthode de fabrique.Write your initialization code in the factory method.

Le tableau suivant montre le constructeur à choisir, en fonction de ces deux facteurs :The following table shows which constructor to choose, based on these two factors:

Objet est accessible parObject will be accessed by Si aucun code d’initialisation n’est requis (constructeur par défaut), utilisezIf no initialization code is required (default constructor), use Si le code d’initialisation est requis, utilisezIf initialization code is required, use
Plusieurs threadsMultiple threads Lazy<T>() Lazy<T>(Func<T>)
Un threadOne thread Lazy<T>(Boolean) avec isThreadSafe défini sur false.Lazy<T>(Boolean) with isThreadSafe set to false. Lazy<T>(Func<T>, Boolean) avec isThreadSafe défini sur false.Lazy<T>(Func<T>, Boolean) with isThreadSafe set to false.

Vous pouvez utiliser une expression lambda pour spécifier la méthode de fabrique.You can use a lambda expression to specify the factory method. Cela permet de conserver tout le code d’initialisation au même endroit.This keeps all the initialization code in one place. L’expression lambda capture le contexte, y compris les arguments que vous passez au constructeur de l’objet initialisé tardivement.The lambda expression captures the context, including any arguments you pass to the lazily initialized object's constructor.

La mise en cache de l’exception lorsque vous utilisez des méthodes de fabrique, les exceptions sont mises en cache.Exception caching When you use factory methods, exceptions are cached. Autrement dit, si la méthode de fabrique lève une heure de l’exception du premier un thread tente d’accéder à la Value propriété de la Lazy<T> de l’objet, la même exception est levée à chaque tentative suivante.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. Cela garantit que chaque appel à la Value propriété produit le même résultat et permet d’éviter des erreurs subtiles qui peuvent survenir si différents threads obtiennent des résultats différents.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. Le Lazy<T> est l’acronyme réel T qui sinon aurait été initialisé à un moment antérieur, généralement lors du démarrage.The Lazy<T> stands in for an actual T that otherwise would have been initialized at some earlier point, usually during startup. Il est généralement irrécupérable d’une défaillance à ce point antérieur.A failure at that earlier point is usually fatal. S’il existe un risque potentiel pour une erreur récupérable, nous vous recommandons de générer la logique de nouvelle tentative dans la routine d’initialisation (dans ce cas, la méthode de fabrique), comme vous le feriez si vous n’utilisiez l’initialisation tardive.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 au verrouillage dans certaines situations, vous souhaiterez peut-être éviter la surcharge de la Lazy<T> comportement de verrouillage par défaut de l’objet.Alternative to locking In certain situations, you might want to avoid the overhead of the Lazy<T> object's default locking behavior. Dans de rares cas, il existe peut-être des interblocages.In rare situations, there might be a potential for deadlocks. Dans ce cas, vous pouvez utiliser la Lazy<T>(LazyThreadSafetyMode) ou Lazy<T>(Func<T>, LazyThreadSafetyMode) constructeur et spécifiez LazyThreadSafetyMode.PublicationOnly.In such cases, you can use the Lazy<T>(LazyThreadSafetyMode) or Lazy<T>(Func<T>, LazyThreadSafetyMode) constructor, and specify LazyThreadSafetyMode.PublicationOnly. Cela permet la Lazy<T> objet pour créer une copie de l’objet initialisé tardivement sur chacun de plusieurs threads si les threads appellent le Value propriété simultanément.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. Le Lazy<T> objet garantit que tous les threads utilisent la même instance de l’objet initialisé tardivement et qu’il rejette les instances qui ne sont pas utilisés.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. Par conséquent, le coût de réduire la surcharge de verrouillage est que votre programme peut parfois créer et à éliminer des copies supplémentaires d’un objet coûteux.Thus, the cost of reducing the locking overhead is that your program might sometimes create and discard extra copies of an expensive object. Dans la plupart des cas, il est peu probable.In most cases, this is unlikely. Les exemples pour le Lazy<T>(LazyThreadSafetyMode) et Lazy<T>(Func<T>, LazyThreadSafetyMode) constructeurs illustrent ce comportement.The examples for the Lazy<T>(LazyThreadSafetyMode) and Lazy<T>(Func<T>, LazyThreadSafetyMode) constructors demonstrate this behavior.

Important

Lorsque vous spécifiez LazyThreadSafetyMode.PublicationOnly, les exceptions sont jamais mises en cache, même si vous spécifiez une méthode de fabrique.When you specify LazyThreadSafetyMode.PublicationOnly, exceptions are never cached, even if you specify a factory method.

Constructeurs équivalents en plus de permettre l’utilisation de LazyThreadSafetyMode.PublicationOnly, le Lazy<T>(LazyThreadSafetyMode) et Lazy<T>(Func<T>, LazyThreadSafetyMode) constructeurs peuvent dupliquer les fonctionnalités des autres constructeurs.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. Le tableau suivant montre les valeurs de paramètre qui produisent un comportement équivalent.The following table shows the parameter values that produce equivalent behavior.

Pour créer un Lazy<T> qui est l’objetTo create a Lazy<T> object that is Pour les constructeurs qui ont un LazyThreadSafetyMode mode paramètre, la valeur mode àFor constructors that have a LazyThreadSafetyMode mode parameter, set mode to Pour les constructeurs qui ont une valeur booléenne isThreadSafe paramètre, la valeur isThreadSafe àFor constructors that have a Boolean isThreadSafe parameter, set isThreadSafe to Pour les constructeurs sans paramètres de sécurité de threadFor constructors with no thread safety parameters
Entièrement les thread-safe ; utilise le verrouillage pour vous assurer que seul un thread initialise la valeur.Fully thread safe; uses locking to ensure that only one thread initializes the value. ExecutionAndPublication true Tous les constructeurs de ce type sont entièrement thread-safe.All such constructors are fully thread safe.
Pas thread-safe.Not thread safe. None false Non applicable.Not applicable.
Entièrement les thread-safe ; concurrence de threads pour initialiser la valeur.Fully thread safe; threads race to initialize the value. PublicationOnly Non applicable.Not applicable. Non applicable.Not applicable.

Autres fonctionnalités pour plus d’informations sur l’utilisation de Lazy<T> avec les champs thread-static, ou en tant que magasin de stockage pour les propriétés, consultez l’initialisation tardive.Other capabilities For information about the use of Lazy<T> with thread-static fields, or as the backing store for properties, see Lazy Initialization.

Constructeurs

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

Initialise une nouvelle instance de la classe Lazy<T>.Initializes a new instance of the Lazy<T> class. Lorsque l'initialisation tardive se produit, le constructeur par défaut du type cible est utilisé.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)

Initialise une nouvelle instance de la classe Lazy<T>.Initializes a new instance of the Lazy<T> class. Lorsque l'initialisation tardive se produit, le constructeur par défaut du type cible et le mode d'initialisation spécifié sont utilisés.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>)

Initialise une nouvelle instance de la classe Lazy<T>.Initializes a new instance of the Lazy<T> class. Lorsque l'initialisation tardive se produit, la fonction d'initialisation spécifiée est utilisée.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)

Initialise une nouvelle instance de la classe Lazy<T>.Initializes a new instance of the Lazy<T> class. Lorsque l'initialisation tardive se produit, la fonction d'initialisation et le mode d'initialisation spécifiés sont utilisés.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)

Initialise une nouvelle instance de la classe Lazy<T> qui utilise la fonction d'initialisation et le mode de cohérence de thread spécifiés.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)

Initialise une nouvelle instance de la classe Lazy<T> qui utilise le constructeur par défaut de T et le mode de cohérence de thread spécifié.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)

Initialise une nouvelle instance de la classe Lazy<T> qui utilise une valeur préinitialisée spécifiée.Initializes a new instance of the Lazy<T> class that uses a preinitialized specified value.

Propriétés

IsValueCreated IsValueCreated IsValueCreated IsValueCreated

Obtient une valeur qui indique si une valeur a été créée pour cette instance Lazy<T>.Gets a value that indicates whether a value has been created for this Lazy<T> instance.

Value Value Value Value

Obtient la valeur initialisée tardivement de l'objet Lazy<T> en cours.Gets the lazily initialized value of the current Lazy<T> instance.

Méthodes

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

Détermine si l'objet spécifié est identique à l'objet actuel.Determines whether the specified object is equal to the current object.

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

Fait office de fonction de hachage par défaut.Serves as the default hash function.

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

Obtient le Type de l'instance actuelle.Gets the Type of the current instance.

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

Crée une copie superficielle de l'objet Object actuel.Creates a shallow copy of the current Object.

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

Crée et retourne une représentation sous forme de chaîne de la propriété Value de cette instance.Creates and returns a string representation of the Value property for this instance.

S’applique à

Cohérence de thread

Par défaut, tous les membres publics et protégés de la Lazy<T> classe sont thread-safe et peuvent être utilisés simultanément par plusieurs threads.By default, all public and protected members of the Lazy<T> class are thread safe and may be used concurrently from multiple threads. Ces garanties de sécurité des threads peuvent être éventuellement supprimées par instance, à l’aide des paramètres pour les constructeurs du type.These thread-safety guarantees may be removed optionally and per instance, using parameters to the type's constructors.

Voir aussi