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 predefinito se non esiste alcun metodo di inizializzazione) usa i blocchi internamente, possono verificarsi deadlock.If the initialization method (or the default 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 di Lazy<T> che non specifica un metodo di inizializzazione, le eccezioni generate dal costruttore predefinito 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 default 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 di Lazy<T> che non specifica un metodo di inizializzazione, le eccezioni generate dal costruttore predefinito 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 default 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 predefinito, 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 default 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

Utilizzare questa enumerazione per specificare il mode parametro di Lazy<T> costruttori.Use this enumeration to specify the mode parameter of Lazy<T> constructors. Gli effetti di tutti i costruttori nella sincronizzazione dei thread possono essere descritti in termini di questa enumerazione, se hanno mode parametri.The effects of all constructors on thread synchronization can be described in terms of this enumeration, whether or not they have mode parameters.

Oggetto Lazy<T> l'istanza viene inizializzata da un metodo di inizializzazione specificato dall'utente o dal costruttore predefinito per T.A Lazy<T> instance is initialized either by a user-specified initialization method or by the default constructor for T. Il metodo di inizializzazione è specificato per il valueFactory parametro di un Lazy<T> 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 che viene creato in modo differito mediante l'istanza di Lazy<T>.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 predefinito per T viene usato per inizializzare il Lazy<T> istanza.If a constructor does not have a valueFactory parameter, the default constructor for T is used to initialize the Lazy<T> instance. In entrambi i casi, si verifica la prima volta che si chiama l'inizializzazione di Lazy<T>.Value proprietà.In either case, initialization occurs the first time you call the Lazy<T>.Value property.

Oltre a specificare la thread safety di un Lazy<T> istanza, questa enumerazione interessa la memorizzazione nella cache di eccezione.In addition to specifying the thread safety of a Lazy<T> instance, this enumeration affects exception caching. Quando le eccezioni vengono memorizzate nella cache per un Lazy<T> istanza, si ottiene solo un'occasione per inizializzare l'istanza.When exceptions are cached for a Lazy<T> instance, you get only one chance to initialize the instance. Se la prima volta che viene generata un'eccezione si chiama il Lazy<T>.Value proprietà, che l'eccezione viene memorizzata nella cache e generata di nuovo a tutte le chiamate successive al Lazy<T>.Value 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 della memorizzazione nella cache delle eccezioni è che qualsiasi due thread ottiene 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 memorizzati nella cache.When you specify the PublicationOnly mode, exceptions are never cached. Quando si specifica nessuno o ExecutionAndPublication, la memorizzazione nella cache dipende dal fatto che si specifica un metodo di inizializzazione o si lascia il costruttore predefinito per T da utilizzare.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. 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, può chiamare il costruttore predefinito per T: 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 default constructor for T: new Lazy<Contents>(() => new Contents(), mode) in C#, or New Lazy(Of Contents)(Function() New Contents()) in Visual Basic. Se si utilizza un costruttore che non specifica un metodo di inizializzazione, le eccezioni generate dal costruttore predefinito 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 default constructor for T are not cached. La tabella seguente riepiloga il comportamento di memorizzazione nella cache di eccezione.The following table summarizes exception caching behavior.

ModalitàMode Usando un metodo di inizializzazioneUsing initialization method Usando il costruttore predefinito per TUsing default 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