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 sans paramètre, 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 parameterless 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 de méthode d’initialisation, les exceptions levées par le constructeur sans paramètre 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 parameterless 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 de méthode d’initialisation, les exceptions levées par le constructeur sans paramètre 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 parameterless 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 sans paramètre, 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 parameterless 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 mode le paramètre Lazy<T> de constructeurs.Use this enumeration to specify the mode parameter of Lazy<T> constructors. Les effets de tous les constructeurs sur la synchronisation des threads peuvent être décrits en termes de cette énumération, qu' mode ils aient ou non des 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.

Une Lazy<T> instance de est initialisée par une méthode d’initialisation spécifiée par l’utilisateur ou par le constructeur sans paramètre Tpour.A Lazy<T> instance is initialized either by a user-specified initialization method or by the parameterless 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 qui est 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’a pas de valueFactory paramètre, le constructeur sans paramètre pour T est utilisé pour initialiser l' Lazy<T> instance.If a constructor does not have a valueFactory parameter, the parameterless constructor for T is used to initialize the Lazy<T> instance. Dans les deux cas, l’initialisation se produit la première fois que Lazy<T>.Value vous appelez la propriété.In either case, initialization occurs the first time you call the Lazy<T>.Value property.

En plus de spécifier la sécurité des threads Lazy<T> d’une instance, cette énumération affecte la mise en cache des exceptions.In addition to specifying the thread safety of a Lazy<T> instance, this enumeration affects exception caching. Lorsque des exceptions sont mises en cache Lazy<T> pour une instance, vous n’avez qu’une chance d’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 Lazy<T>.Value la propriété, cette exception est mise en cache et levée à nouveau sur tous les appels Lazy<T>.Value suivants à la 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 obtiennent toujours le même résultat, même si 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. Quand vous spécifiez None ou ExecutionAndPublication, la mise en cache varie selon que vous spécifiez une méthode d’initialisation ou que T vous autorisez l’utilisation du constructeur sans paramètre pour.When you specify None or ExecutionAndPublication, caching depends on whether you specify an initialization method or allow the parameterless 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, il peut appeler le constructeur sans paramètre pour T: new Lazy<Contents>(() => new Contents(), mode) dans C#, ou New Lazy(Of Contents)(Function() New Contents()) dans Visual Basic.For example, it might call the parameterless 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 de méthode d’initialisation, les exceptions levées par le constructeur sans paramètre T pour ne sont pas mises en cache.If you use a constructor that does not specify an initialization method, exceptions that are thrown by the parameterless constructor for T are not cached. Le tableau suivant résume le comportement de la mise en cache des exceptions.The following table summarizes exception caching behavior.

ModeMode Utilisation de la méthode d’initialisationUsing initialization method Utilisation d’un constructeur sans paramètre pourTUsing parameterless 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