Esporta (0) Stampa
Espandi tutto
Il presente articolo è stato tradotto automaticamente. Passare il puntatore sulle frasi nell'articolo per visualizzare il testo originale. Ulteriori informazioni.
Traduzione
Originale

Classe ThreadStaticAttribute

Indica che il valore di un campo statico è univoco per ciascun thread.

System.Object
  System.Attribute
    System.ThreadStaticAttribute

Spazio dei nomi:  System
Assembly:  mscorlib (in mscorlib.dll)

[SerializableAttribute]
[ComVisibleAttribute(true)]
[AttributeUsageAttribute(AttributeTargets.Field, Inherited = false)]
public class ThreadStaticAttribute : Attribute

Il tipo ThreadStaticAttribute espone i seguenti membri.

  NomeDescrizione
Metodo pubblicoSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreThreadStaticAttributeInizializza una nuova istanza della classe ThreadStaticAttribute.
In alto

  NomeDescrizione
Proprietà pubblicaTypeId Quando implementato in una classe derivata, ottiene un identificatore univoco per questo Attribute. (Ereditato da Attribute)
In alto

  NomeDescrizione
Metodo pubblicoSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreEqualsInfrastruttura. Restituisce un valore che indica se l'istanza è uguale ad un oggetto specificato. (Ereditato da Attribute)
Metodo protettoSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreFinalize Consente a un oggetto di provare a liberare risorse ed eseguire altre operazioni di pulizia prima che l'oggetto stesso venga reclamato dalla procedura di Garbage Collection. (Ereditato da Object)
Metodo pubblicoSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreGetHashCode Restituisce il codice hash per l'istanza corrente. (Ereditato da Attribute)
Metodo pubblicoSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreGetType Ottiene il Type dell'istanza corrente. (Ereditato da Object)
Metodo pubblicoIsDefaultAttribute Quando viene eseguito l'override in una classe derivata, indica se il valore di questa istanza è il valore predefinito per la classe derivata. (Ereditato da Attribute)
Metodo pubblicoMatch Quando viene eseguito l'override in una classe derivata, restituisce un valore che indica se questa istanza equivale a un oggetto specificato. (Ereditato da Attribute)
Metodo protettoSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreMemberwiseClone Crea una copia dei riferimenti dell'oggetto Object corrente. (Ereditato da Object)
Metodo pubblicoSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreToString Restituisce una stringa che rappresenta l'oggetto corrente. (Ereditato da Object)
In alto

  NomeDescrizione
Implementazione esplicita dell'interfacciaMetodo privato_Attribute.GetIDsOfNames Esegue il mapping di un set di nomi a un corrispondente set di identificatori di dispatch. (Ereditato da Attribute)
Implementazione esplicita dell'interfacciaMetodo privato_Attribute.GetTypeInfo Recupera le informazioni sui tipi per un oggetto, che possono essere utilizzate per ottenere informazioni sul tipo per un'interfaccia. (Ereditato da Attribute)
Implementazione esplicita dell'interfacciaMetodo privato_Attribute.GetTypeInfoCount Recupera il numero di interfacce di informazioni sui tipi che un oggetto fornisce (0 o 1). (Ereditato da Attribute)
Implementazione esplicita dell'interfacciaMetodo privato_Attribute.Invoke Fornisce l'accesso alle proprietà ed ai metodi esposti da un oggetto. (Ereditato da Attribute)
In alto

Un campo static contrassegnato con ThreadStaticAttribute non viene condiviso tra i thread. Ciascun thread in esecuzione dispone di un'istanza separata del campo e consente di impostare e ottenere in modo indipendente valori per quel campo. Se si accede al campo in un thread diverso, il valore del campo sarà diverso.

Si noti che oltre ad applicare l'attributo ThreadStaticAttribute ad un campo, è inoltre necessario definirlo come campo static (in C#) o campo Shared (in Visual Basic).

NotaNota

Non specificare valori iniziali per campi contrassegnati con ThreadStaticAttribute, poiché tale inizializzazione si verifica solo una volta, durante l'esecuzione del costruttore di classi, e di conseguenza riguarda solo un thread. Se non viene specificato un valore iniziale, il campo verrà inizializzato con il valore predefinito se si tratta di un tipo valore o con null se si tratta di un tipo di riferimento.

Utilizzare questo attributo senza modificarlo e non eseguire una derivazione da esso.

Per ulteriori informazioni sull'utilizzo degli attributi, vedere Estensione di metadati mediante attributi.

Nell'esempio seguente viene creata un'istanza di un generatore di numeri casuali, vengono creati 10 thread oltre al thread principale ed infine vengono generati due milioni di numeri casuali in ogni thread. Utilizza l'attributo ThreadStaticAttribute per calcolare la somma e il conteggio dei numeri casuali per thread. Definisce inoltre due campi per thread, previous e abnormal, che consentono di rilevare il danneggiamento del generatore di numeri casuali.


using System;
using System.Threading;

public class Example
{
   [ThreadStatic] static double previous = 0.0;
   [ThreadStatic] static double sum = 0.0;
   [ThreadStatic] static int calls = 0;
   [ThreadStatic] static bool abnormal;
   static int totalNumbers = 0;
   static CountdownEvent countdown;
   private static Object lockObj;
   Random rand;

   public Example()
   { 
      rand = new Random();
      lockObj = new Object();
      countdown = new CountdownEvent(1);
   } 

   public static void Main()
   {
      Example ex = new Example();
      Thread.CurrentThread.Name = "Main";
      ex.Execute();
      countdown.Wait();
      Console.WriteLine("{0:N0} random numbers were generated.", totalNumbers);
   }

   private void Execute()
   {   
      for (int threads = 1; threads <= 10; threads++)
      {
         Thread newThread = new Thread(new ThreadStart(this.GetRandomNumbers));
         countdown.AddCount();
         newThread.Name = threads.ToString();
         newThread.Start();
      }
      this.GetRandomNumbers();
   }

   private void GetRandomNumbers()
   {
      double result = 0.0;


      for (int ctr = 0; ctr < 2000000; ctr++)
      {
         lock (lockObj) {
            result = rand.NextDouble();
            calls++;
            Interlocked.Increment(ref totalNumbers);
            // We should never get the same random number twice.
            if (result == previous) {
               abnormal = true;
               break;
            }
            else {
               previous = result;
               sum += result;
            }   
         }
      }
      // get last result
      if (abnormal)
         Console.WriteLine("Result is {0} in {1}", previous, Thread.CurrentThread.Name);

      Console.WriteLine("Thread {0} finished random number generation.", Thread.CurrentThread.Name);
      Console.WriteLine("Sum = {0:N4}, Mean = {1:N4}, n = {2:N0}\n", sum, sum/calls, calls);        
      countdown.Signal();
   }
}
// The example displays output similar to the following:
//    Thread 1 finished random number generation.
//    Total = 1,000,556.7483, Mean = 0.5003, n = 2,000,000
//    
//    Thread 6 finished random number generation.
//    Total = 999,704.3865, Mean = 0.4999, n = 2,000,000
//    
//    Thread 2 finished random number generation.
//    Total = 999,680.8904, Mean = 0.4998, n = 2,000,000
//    
//    Thread 10 finished random number generation.
//    Total = 999,437.5132, Mean = 0.4997, n = 2,000,000
//    
//    Thread 8 finished random number generation.
//    Total = 1,000,663.7789, Mean = 0.5003, n = 2,000,000
//    
//    Thread 4 finished random number generation.
//    Total = 999,379.5978, Mean = 0.4997, n = 2,000,000
//    
//    Thread 5 finished random number generation.
//    Total = 1,000,011.0605, Mean = 0.5000, n = 2,000,000
//    
//    Thread 9 finished random number generation.
//    Total = 1,000,637.4556, Mean = 0.5003, n = 2,000,000
//    
//    Thread Main finished random number generation.
//    Total = 1,000,676.2381, Mean = 0.5003, n = 2,000,000
//    
//    Thread 3 finished random number generation.
//    Total = 999,951.1025, Mean = 0.5000, n = 2,000,000
//    
//    Thread 7 finished random number generation.
//    Total = 1,000,844.5217, Mean = 0.5004, n = 2,000,000
//    
//    22,000,000 random numbers were generated.


L'esempio utilizza l'istruzione lock in C# e il costrutto SyncLock in Visual Basic per sincronizzare l'accesso al generatore di numeri casuali. Ciò impedisce il danneggiamento del generatore di numeri casuali, che in genere comporta la restituzione del valore zero per tutte le chiamate successive.

Viene inoltre utilizzata la classe CountdownEvent per garantire che ciascun thread abbia completato di generare numeri casuali prima di visualizzare il numero totale di chiamate. In caso contrario, se il thread principale termina l'esecuzione prima degli altri thread generati, viene visualizzato un valore inaccurato per il numero totale di chiamate al metodo.

.NET Framework

Supportato in: 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Supportato in: 4, 3.5 SP1

Libreria di classi portabile

Supportato in: Libreria di classi portabile

.NET per applicazioni Windows Store

Supportato in: Windows 8

.NET per applicazioni Windows Phone

Supportato in: Windows Phone 8, Silverlight 8.1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (ruoli di base del server non supportati), Windows Server 2008 R2 (ruoli di base del server supportati con SP1 o versione successiva, Itanium non supportato)

.NET Framework non supporta tutte le versioni di ciascuna piattaforma. Per un elenco delle versioni supportate, vedere Requisiti di sistema di .NET Framework.

Qualsiasi membro static (Shared in Visual Basic) pubblico di questo tipo è thread-safe. I membri di istanza non sono garantiti come thread-safe.

Aggiunte alla community

AGGIUNGI
Mostra:
© 2014 Microsoft