LazyThreadSafetyMode LazyThreadSafetyMode LazyThreadSafetyMode LazyThreadSafetyMode Enum

Définition

Spécifie comment une instance de Lazy<T> synchronise l’accès entre plusieurs threads.Specifies how a Lazy<T> instance synchronizes access among multiple threads.

public enum class LazyThreadSafetyMode
public enum LazyThreadSafetyMode
type LazyThreadSafetyMode = 
Public Enum LazyThreadSafetyMode
Héritage
LazyThreadSafetyModeLazyThreadSafetyModeLazyThreadSafetyModeLazyThreadSafetyMode

Champs

ExecutionAndPublication ExecutionAndPublication ExecutionAndPublication ExecutionAndPublication 2

Des verrous sont utilisés pour qu’un seul thread puisse initialiser une instance de Lazy<T> d’une façon thread-safe.Locks are used to ensure that only a single thread can initialize a Lazy<T> instance in a thread-safe manner. Si la méthode d’initialisation (ou le constructeur par défaut, s’il n’existe aucune méthode d’initialisation) utilise des verrous en interne, des blocages peuvent se produire.If the initialization method (or the default constructor, if there is no initialization method) uses locks internally, deadlocks can occur. Si vous utilisez un constructeur Lazy<T> qui spécifie une méthode d’initialisation (paramètre valueFactory) et si cette méthode d’initialisation lève une exception (ou échoue à gérer une exception), la première fois que vous appelez la propriété Value, l’exception est mise en cache et levée à nouveau lors des appels ultérieurs à la propriété Value.If you use a Lazy<T> constructor that specifies an initialization method (valueFactory parameter), and if that initialization method throws an exception (or fails to handle an exception) the first time you call the Value property, then the exception is cached and thrown again on subsequent calls to the Value property. Si vous utilisez un constructeur Lazy<T> qui ne spécifie pas une méthode d’initialisation, les exceptions levées par le constructeur par défaut pour T ne sont pas mises en cache.If you use a Lazy<T> constructor that does not specify an initialization method, exceptions that are thrown by the default constructor for T are not cached. Dans ce cas, un appel ultérieur à la propriété Value peut initialiser correctement l’instance de Lazy<T>.In that case, a subsequent call to the Value property might successfully initialize the Lazy<T> instance. Si la méthode d’initialisation accède de façon récursive à la propriété Value de l’instance de Lazy<T>, une InvalidOperationException est levée.If the initialization method recursively accesses the Value property of the Lazy<T> instance, an InvalidOperationException is thrown.

None None None None 0

L’instance de Lazy<T> n’est pas thread-safe ; si plusieurs threads accèdent à l’instance, son comportement est non défini.The Lazy<T> instance is not thread safe; if the instance is accessed from multiple threads, its behavior is undefined. Utilisez ce mode seulement quand des performances élevées sont cruciales et s’il est certain que l’instance de Lazy<T> n’est jamais initialisée par plusieurs threads.Use this mode only when high performance is crucial and the Lazy<T> instance is guaranteed never to be initialized from more than one thread. Si vous utilisez un constructeur Lazy<T> qui spécifie une méthode d’initialisation (paramètre valueFactory) et si cette méthode d’initialisation lève une exception (ou échoue à gérer une exception), la première fois que vous appelez la propriété Value, l’exception est mise en cache et levée à nouveau lors des appels ultérieurs à la propriété Value.If you use a Lazy<T> constructor that specifies an initialization method (valueFactory parameter), and if that initialization method throws an exception (or fails to handle an exception) the first time you call the Value property, then the exception is cached and thrown again on subsequent calls to the Value property. Si vous utilisez un constructeur Lazy<T> qui ne spécifie pas une méthode d’initialisation, les exceptions levées par le constructeur par défaut pour T ne sont pas mises en cache.If you use a Lazy<T> constructor that does not specify an initialization method, exceptions that are thrown by the default constructor for T are not cached. Dans ce cas, un appel ultérieur à la propriété Value peut initialiser correctement l’instance de Lazy<T>.In that case, a subsequent call to the Value property might successfully initialize the Lazy<T> instance. Si la méthode d’initialisation accède de façon récursive à la propriété Value de l’instance de Lazy<T>, une InvalidOperationException est levée.If the initialization method recursively accesses the Value property of the Lazy<T> instance, an InvalidOperationException is thrown.

PublicationOnly PublicationOnly PublicationOnly PublicationOnly 1

Quand plusieurs threads tentent simultanément d’initialiser une instance de Lazy<T>, tous les threads sont autorisés à exécuter la méthode d’initialisation (ou le constructeur par défaut, s’il n’existe aucune méthode d’initialisation).When multiple threads try to initialize a Lazy<T> instance simultaneously, all threads are allowed to run the initialization method (or the default constructor, if there is no initialization method). Le premier thread qui termine l’initialisation définit la valeur de l’instance de Lazy<T>.The first thread to complete initialization sets the value of the Lazy<T> instance. Cette valeur est retournée à tous les autres threads qui exécutaient simultanément la méthode d’initialisation, à moins que la méthode d’initialisation lève des exceptions sur ces threads.That value is returned to any other threads that were simultaneously running the initialization method, unless the initialization method throws exceptions on those threads. Toutes les instances de T qui ont été créées par les threads concurrents sont abandonnées.Any instances of T that were created by the competing threads are discarded. Si la méthode d’initialisation lève une exception sur un thread, l’exception est propagée à partir de la propriété Value sur ce thread.If the initialization method throws an exception on any thread, the exception is propagated out of the Value property on that thread. L’exception n’est pas mise en cache.The exception is not cached. La valeur de la propriété IsValueCreated reste false, et les appels suivants à la propriété Value par le thread où l’exception a été levée ou par d’autres threads provoquent la réexécution de la méthode d’initialisation.The value of the IsValueCreated property remains false, and subsequent calls to the Value property, either by the thread where the exception was thrown or by other threads, cause the initialization method to run again. Si la méthode d’initialisation accède de façon récursive à la propriété Value de l’instance de Lazy<T>, aucune exception n’est levée.If the initialization method recursively accesses the Value property of the Lazy<T> instance, no exception is thrown.

Remarques

Utilisez cette énumération pour spécifier le mode paramètre de Lazy<T> constructeurs.Use this enumeration to specify the mode parameter of Lazy<T> constructors. Les effets de tous les constructeurs sur la synchronisation de thread peuvent être décrits en termes de cette énumération, s’ils ont mode paramètres.The effects of all constructors on thread synchronization can be described in terms of this enumeration, whether or not they have mode parameters.

Un Lazy<T> instance est initialisée par une méthode d’initialisation spécifié par l’utilisateur ou par le constructeur par défaut T.A Lazy<T> instance is initialized either by a user-specified initialization method or by the default constructor for T. La méthode d’initialisation est spécifiée par le valueFactory paramètre d’un Lazy<T> constructeur.The initialization method is specified by the valueFactory parameter of a Lazy<T> constructor. La méthode retourne une instance de T, qui est le type instancié tardivement par l’instance de Lazy<T>.The method returns an instance of T, which is the type that is lazily instantiated by the instance of Lazy<T>. Si un constructeur n’est pas un valueFactory paramètre, le constructeur par défaut T est utilisée pour initialiser le Lazy<T> instance.If a constructor does not have a valueFactory parameter, the default constructor for T is used to initialize the Lazy<T> instance. Dans les deux cas, l’initialisation se produit la première fois que vous appelez le Lazy<T>.Value propriété.In either case, initialization occurs the first time you call the Lazy<T>.Value property.

Outre la spécification de la sécurité des threads d’un Lazy<T> instance, cette énumération affecte la mise en cache de l’exception.In addition to specifying the thread safety of a Lazy<T> instance, this enumeration affects exception caching. Lorsque les exceptions sont mises en cache pour un Lazy<T> instance, vous obtenez uniquement une chance pour initialiser l’instance.When exceptions are cached for a Lazy<T> instance, you get only one chance to initialize the instance. Si une exception est levée la première fois que vous appelez le Lazy<T>.Value propriété, que l’exception est mis en cache et levée à nouveau sur tous les appels ultérieurs à la Lazy<T>.Value propriété.If an exception is thrown the first time you call the Lazy<T>.Value property, that exception is cached and rethrown on all subsequent calls to the Lazy<T>.Value property. L’avantage de la mise en cache des exceptions est que deux threads toujours obtiennent le même résultat, même lorsque des erreurs se produisent.The advantage of caching exceptions is that any two threads always get the same result, even when errors occur.

Lorsque vous spécifiez le mode PublicationOnly, les exceptions ne sont jamais mises en cache.When you specify the PublicationOnly mode, exceptions are never cached. Lorsque vous spécifiez None ou ExecutionAndPublication, la mise en cache varie selon que vous spécifiez une méthode d’initialisation ou autoriser le constructeur par défaut T à utiliser.When you specify None or ExecutionAndPublication, caching depends on whether you specify an initialization method or allow the default constructor for T to be used. La spécification d’une méthode d’initialisation permet la mise en cache des exceptions pour ces deux modes.Specifying an initialization method enables exception caching for these two modes. La méthode d’initialisation peut être très simple.The initialization method can be very simple. Par exemple, elle peut appeler le constructeur par défaut de T (new Lazy<Contents>(() => new Contents(), mode) en C# ou New Lazy(Of Contents)(Function() New Contents()) en Visual Basic).For example, it might call the default constructor for T: new Lazy<Contents>(() => new Contents(), mode) in C#, or New Lazy(Of Contents)(Function() New Contents()) in Visual Basic. Si vous utilisez un constructeur qui ne spécifie pas une méthode d’initialisation, les exceptions levées par le constructeur par défaut T ne sont pas mises en cache.If you use a constructor that does not specify an initialization method, exceptions that are thrown by the default constructor for T are not cached. Le tableau suivant récapitule le comportement de mise en cache des exceptions.The following table summarizes exception caching behavior.

ModeMode À l’aide de la méthode d’initialisationUsing initialization method À l’aide du constructeur par défaut TUsing default constructor for T
Aucun.None Mis en cacheCached Non mis en cacheNot cached
PublicationOnlyPublicationOnly Non mis en cacheNot cached Non mis en cacheNot cached
ExecutionAndPublicationExecutionAndPublication Mis en cacheCached Non mis en cacheNot cached

S’applique à

Voir aussi