LazyThreadSafetyMode LazyThreadSafetyMode LazyThreadSafetyMode LazyThreadSafetyMode Enum

Definizione

Specifica il modo in cui un'istanza di Lazy<T> sincronizza l'accesso tra più thread.Specifies how a Lazy<T> instance synchronizes access among multiple threads.

public enum class LazyThreadSafetyMode
public enum LazyThreadSafetyMode
type LazyThreadSafetyMode = 
Public Enum LazyThreadSafetyMode
Ereditarietà
LazyThreadSafetyModeLazyThreadSafetyModeLazyThreadSafetyModeLazyThreadSafetyMode

Campi

ExecutionAndPublication ExecutionAndPublication ExecutionAndPublication ExecutionAndPublication 2

Per garantire che solo un singolo thread possa inizializzare un'istanza di Lazy<T> in modalità thread-safe, vengono usati i blocchi.Locks are used to ensure that only a single thread can initialize a Lazy<T> instance in a thread-safe manner. Se il metodo di inizializzazione (o il costruttore senza parametri se non esiste alcun metodo di inizializzazione) usa i blocchi internamente, possono verificarsi deadlock.If the initialization method (or the parameterless constructor, if there is no initialization method) uses locks internally, deadlocks can occur. Se si usa un costruttore di Lazy<T> che specifica un metodo di inizializzazione (parametro valueFactory) e se tale metodo di inizializzazione genera un'eccezione (o non è in grado di gestire un'eccezione) la prima volta che si chiama la proprietà Value, l'eccezione viene memorizzata nella cache e generata di nuovo per le chiamate successive alla proprietà 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. Se si usa un costruttore Lazy<T> che non specifica un metodo di inizializzazione, le eccezioni generate dal costruttore senza parametri per T non vengono memorizzate nella 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. In tal caso, è possibile che una chiamata successiva alla proprietà Value inizializzi correttamente l'istanza di Lazy<T>.In that case, a subsequent call to the Value property might successfully initialize the Lazy<T> instance. Se il metodo di inizializzazione accede in modo ricorsivo alla proprietà Value dell'istanza di Lazy<T>, verrà generata un'eccezione InvalidOperationException.If the initialization method recursively accesses the Value property of the Lazy<T> instance, an InvalidOperationException is thrown.

None None None None 0

L'istanza di Lazy<T> non è thread-safe. Se l'istanza è accessibile da più thread, il comportamento sarà indefinito.The Lazy<T> instance is not thread safe; if the instance is accessed from multiple threads, its behavior is undefined. Usare questa modalità solo quando è fondamentale ottenere prestazioni elevate e l'istanza di Lazy<T> non potrà mai essere inizializzata da più thread.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. Se si usa un costruttore di Lazy<T> che specifica un metodo di inizializzazione (parametro valueFactory) e se tale metodo di inizializzazione genera un'eccezione (o non è in grado di gestire un'eccezione) la prima volta che si chiama la proprietà Value, l'eccezione viene memorizzata nella cache e generata di nuovo per le chiamate successive alla proprietà 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. Se si usa un costruttore Lazy<T> che non specifica un metodo di inizializzazione, le eccezioni generate dal costruttore senza parametri per T non vengono memorizzate nella 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. In tal caso, è possibile che una chiamata successiva alla proprietà Value inizializzi correttamente l'istanza di Lazy<T>.In that case, a subsequent call to the Value property might successfully initialize the Lazy<T> instance. Se il metodo di inizializzazione accede in modo ricorsivo alla proprietà Value dell'istanza di Lazy<T>, verrà generata un'eccezione InvalidOperationException.If the initialization method recursively accesses the Value property of the Lazy<T> instance, an InvalidOperationException is thrown.

PublicationOnly PublicationOnly PublicationOnly PublicationOnly 1

Quando più thread tentano di inizializzare un'istanza di Lazy<T> contemporaneamente, tutti i thread possono eseguire il metodo di inizializzazione (o il costruttore senza parametri, se non esiste alcun metodo di inizializzazione).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). Il primo thread la cui inizializzazione viene completata imposta il valore dell'istanza di Lazy<T>.The first thread to complete initialization sets the value of the Lazy<T> instance. Questo valore viene restituito a qualsiasi altro thread che esegue simultaneamente il metodo di inizializzazione, a meno che il metodo di inizializzazione non generi eccezioni per tali thread.That value is returned to any other threads that were simultaneously running the initialization method, unless the initialization method throws exceptions on those threads. Tutte le istanze di T che sono state create dai thread concorrenti vengono ignorate.Any instances of T that were created by the competing threads are discarded. Se il metodo di inizializzazione genera un'eccezione in qualsiasi thread, l'eccezione viene propagata fuori dalla proprietà Value sul thread interessato.If the initialization method throws an exception on any thread, the exception is propagated out of the Value property on that thread. L'eccezione non viene memorizzata nella cache.The exception is not cached. Il valore della proprietà IsValueCreated rimane false e le chiamate successive alla proprietà Value proprietà (da parte del thread in cui è stata generata l'eccezione o da parte di altri thread) comporta la riesecuzione del metodo di inizializzazione.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. Se il metodo di inizializzazione accede in modo ricorsivo alla proprietà Value dell'istanza di Lazy<T>, non verrà generata alcuna eccezione.If the initialization method recursively accesses the Value property of the Lazy<T> instance, no exception is thrown.

Commenti

Usare questa enumerazione per specificare il mode parametro dei Lazy<T> costruttori.Use this enumeration to specify the mode parameter of Lazy<T> constructors. Gli effetti di tutti i costruttori sulla sincronizzazione dei thread possono essere descritti in termini di questa enumerazione, indipendentemente dal fatto mode che dispongano o meno di parametri.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> istanza viene inizializzata da un metodo di inizializzazione specificato dall'utente o dal costruttore senza parametri Tper.A Lazy<T> instance is initialized either by a user-specified initialization method or by the parameterless constructor for T. Il metodo di inizializzazione viene specificato valueFactory dal parametro di Lazy<T> un costruttore.The initialization method is specified by the valueFactory parameter of a Lazy<T> constructor. Il metodo restituisce un'istanza di T, ovvero il tipo di cui viene creata un'istanza in modo differito Lazy<T>dall'istanza di.The method returns an instance of T, which is the type that is lazily instantiated by the instance of Lazy<T>. Se un costruttore non ha un valueFactory parametro, il costruttore senza parametri per T viene usato per inizializzare l' Lazy<T> istanza.If a constructor does not have a valueFactory parameter, the parameterless constructor for T is used to initialize the Lazy<T> instance. In entrambi i casi, l'inizializzazione viene eseguita la prima Lazy<T>.Value volta che si chiama la proprietà.In either case, initialization occurs the first time you call the Lazy<T>.Value property.

Oltre a specificare il thread safety di un' Lazy<T> istanza, questa enumerazione influiscono sulla memorizzazione delle eccezioni nella cache.In addition to specifying the thread safety of a Lazy<T> instance, this enumeration affects exception caching. Quando le eccezioni vengono memorizzate Lazy<T> nella cache per un'istanza di, si ottiene solo un'opportunità per inizializzare l'istanza.When exceptions are cached for a Lazy<T> instance, you get only one chance to initialize the instance. Se viene generata un'eccezione la prima volta che si chiama Lazy<T>.Value la proprietà, tale eccezione viene memorizzata nella cache e rigenerata in tutte Lazy<T>.Value le chiamate successive alla proprietà.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. Il vantaggio delle eccezioni di Caching è che i due thread ottengono sempre lo stesso risultato, anche quando si verificano errori.The advantage of caching exceptions is that any two threads always get the same result, even when errors occur.

Quando si specifica la modalità PublicationOnly, le eccezioni non vengono mai memorizzate nella cache.When you specify the PublicationOnly mode, exceptions are never cached. Quando si specifica None o ExecutionAndPublication, la memorizzazione nella cache varia a seconda che si specifichi un metodo T di inizializzazione o si consenta l'utilizzo del costruttore senza parametri.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. Se si specifica un metodo di inizializzazione, la memorizzazione nella cache delle eccezioni viene abilitata per queste due modalità.Specifying an initialization method enables exception caching for these two modes. Il metodo di inizializzazione può essere molto semplice.The initialization method can be very simple. Ad esempio, potrebbe chiamare il costruttore senza parametri Tper: new Lazy<Contents>(() => new Contents(), mode) in C#o New Lazy(Of Contents)(Function() New Contents()) in 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. Se si usa un costruttore che non specifica un metodo di inizializzazione, le eccezioni generate dal costruttore senza parametri per T non vengono memorizzate nella 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. Nella tabella seguente viene riepilogato il comportamento della memorizzazione nella cache delle eccezioni.The following table summarizes exception caching behavior.

ModalitàMode Utilizzo del metodo di inizializzazioneUsing initialization method Uso del costruttore senza parametri perTUsing parameterless constructor for T
nessunoNone Memorizzata nella cacheCached Non memorizzato nella cacheNot cached
PublicationOnlyPublicationOnly Non memorizzato nella cacheNot cached Non memorizzato nella cacheNot cached
ExecutionAndPublicationExecutionAndPublication Memorizzata nella cacheCached Non memorizzato nella cacheNot cached

Si applica a

Vedi anche