Thread Thread Thread Thread Class

Definizione

Crea e controlla un thread, ne imposta le priorità e ne ottiene lo stato.Creates and controls a thread, sets its priority, and gets its status.

public ref class Thread sealed : System::Runtime::ConstrainedExecution::CriticalFinalizerObject, System::Runtime::InteropServices::_Thread
[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)]
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class Thread : System.Runtime.ConstrainedExecution.CriticalFinalizerObject, System.Runtime.InteropServices._Thread
type Thread = class
    inherit CriticalFinalizerObject
    interface _Thread
Public NotInheritable Class Thread
Inherits CriticalFinalizerObject
Implements _Thread
Ereditarietà
Attributi
Implementazioni

Esempi

L'esempio seguente illustra le funzionalità di threading semplici.The following example demonstrates simple threading functionality.

// [C++]
// Compile using /clr option.
using namespace System;
using namespace System::Threading;

// Simple threading scenario:  Start a Shared method running
// on a second thread.
public ref class ThreadExample
{
public:

   // The ThreadProc method is called when the thread starts.
   // It loops ten times, writing to the console and yielding 
   // the rest of its time slice each time, and then ends.
   static void ThreadProc()
   {
      for ( int i = 0; i < 10; i++ )
      {
         Console::Write(  "ThreadProc: " );
         Console::WriteLine( i );
         
         // Yield the rest of the time slice.
         Thread::Sleep( 0 );

      }
   }

};

int main()
{
   Console::WriteLine( "Main thread: Start a second thread." );
   
   // Create the thread, passing a ThreadStart delegate that
   // represents the ThreadExample::ThreadProc method.  For a 
   // delegate representing a static method, no object is
   // required.
   Thread^ oThread = gcnew Thread( gcnew ThreadStart( &ThreadExample::ThreadProc ) );
   
   // Start ThreadProc.  Note that on a uniprocessor, the new 
   // thread does not get any processor time until the main thread 
   // is preempted or yields.  Uncomment the Thread::Sleep that 
   // follows oThread->Start() to see the difference.
   oThread->Start();
   
   //Thread::Sleep(0);
   for ( int i = 0; i < 4; i++ )
   {
      Console::WriteLine(  "Main thread: Do some work." );
      Thread::Sleep( 0 );

   }
   Console::WriteLine(  "Main thread: Call Join(), to wait until ThreadProc ends." );
   oThread->Join();
   Console::WriteLine(  "Main thread: ThreadProc.Join has returned.  Press Enter to end program." );
   Console::ReadLine();
   return 0;
}

using System;
using System.Threading;

// Simple threading scenario:  Start a static method running
// on a second thread.
public class ThreadExample {
    // The ThreadProc method is called when the thread starts.
    // It loops ten times, writing to the console and yielding 
    // the rest of its time slice each time, and then ends.
    public static void ThreadProc() {
        for (int i = 0; i < 10; i++) {
            Console.WriteLine("ThreadProc: {0}", i);
            // Yield the rest of the time slice.
            Thread.Sleep(0);
        }
    }

    public static void Main() {
        Console.WriteLine("Main thread: Start a second thread.");
        // The constructor for the Thread class requires a ThreadStart 
        // delegate that represents the method to be executed on the 
        // thread.  C# simplifies the creation of this delegate.
        Thread t = new Thread(new ThreadStart(ThreadProc));

        // Start ThreadProc.  Note that on a uniprocessor, the new 
        // thread does not get any processor time until the main thread 
        // is preempted or yields.  Uncomment the Thread.Sleep that 
        // follows t.Start() to see the difference.
        t.Start();
        //Thread.Sleep(0);

        for (int i = 0; i < 4; i++) {
            Console.WriteLine("Main thread: Do some work.");
            Thread.Sleep(0);
        }

        Console.WriteLine("Main thread: Call Join(), to wait until ThreadProc ends.");
        t.Join();
        Console.WriteLine("Main thread: ThreadProc.Join has returned.  Press Enter to end program.");
        Console.ReadLine();
    }
}
Imports System
Imports System.Threading

' Simple threading scenario:  Start a Shared method running
' on a second thread.
Public Class ThreadExample
    ' The ThreadProc method is called when the thread starts.
    ' It loops ten times, writing to the console and yielding 
    ' the rest of its time slice each time, and then ends.
    Public Shared Sub ThreadProc()
        Dim i As Integer
        For i = 0 To 9
            Console.WriteLine("ThreadProc: {0}", i)
            ' Yield the rest of the time slice.
            Thread.Sleep(0)
        Next
    End Sub

    Public Shared Sub Main()
        Console.WriteLine("Main thread: Start a second thread.")
        ' The constructor for the Thread class requires a ThreadStart 
        ' delegate.  The Visual Basic AddressOf operator creates this
        ' delegate for you.
        Dim t As New Thread(AddressOf ThreadProc)

        ' Start ThreadProc.  Note that on a uniprocessor, the new 
        ' thread does not get any processor time until the main thread 
        ' is preempted or yields.  Uncomment the Thread.Sleep that 
        ' follows t.Start() to see the difference.
        t.Start()
        'Thread.Sleep(0)

        Dim i As Integer
        For i = 1 To 4
            Console.WriteLine("Main thread: Do some work.")
            Thread.Sleep(0)
        Next

        Console.WriteLine("Main thread: Call Join(), to wait until ThreadProc ends.")
        t.Join()
        Console.WriteLine("Main thread: ThreadProc.Join has returned.  Press Enter to end program.")
        Console.ReadLine()
    End Sub
End Class

Questo codice restituisce un output simile al seguente:This code produces output similar to the following:

[VB, C++, C#]  
Main thread: Start a second thread.  
Main thread: Do some work.  
ThreadProc: 0  
Main thread: Do some work.  
ThreadProc: 1  
Main thread: Do some work.  
ThreadProc: 2  
Main thread: Do some work.  
ThreadProc: 3  
Main thread: Call Join(), to wait until ThreadProc ends.  
ThreadProc: 4  
ThreadProc: 5  
ThreadProc: 6  
ThreadProc: 7  
ThreadProc: 8  
ThreadProc: 9  
Main thread: ThreadProc.Join has returned.  Press Enter to end program.  

Commenti

Quando viene avviato un processo, common language runtime crea automaticamente un thread singolo in primo piano per eseguire il codice dell'applicazione.When a process starts, the common language runtime automatically creates a single foreground thread to execute application code. Insieme a questo thread principale in primo piano, un processo può creare uno o più thread per eseguire una parte del codice del programma associato al processo.Along with this main foreground thread, a process can create one or more threads to execute a portion of the program code associated with the process. È possibile eseguire i thread in primo piano o in background.These threads can execute either in the foreground or in the background. Inoltre, è possibile usare il ThreadPool classe per eseguire il codice nei thread di lavoro che sono gestiti da common language runtime.In addition, you can use the ThreadPool class to execute code on worker threads that are managed by the common language runtime.

Contenuto della sezioneIn this section

Avvio di un thread Starting a thread
Recupero di oggetti Thread Retrieving Thread objects
Thread in primo piano e sfondo Foreground and background threads
Impostazioni cultura e thread Culture and threads
Recupero di informazioni e controllo di threadGetting information about and controlling threads

Avvio di un threadStarting a thread

Si avvia un thread fornendo un delegato che rappresenta il metodo che di thread consiste nell'eseguire nel relativo costruttore di classe.You start a thread by supplying a delegate that represents the method the thread is to execute in its class constructor. È quindi possibile chiamare il Start metodo per avviare l'esecuzione.You then call the Start method to begin execution.

Il Thread costruttori possono assumere uno dei tipi di delegati di due, a seconda del fatto che è possibile passare un argomento al metodo da eseguire:The Thread constructors can take either of two delegate types, depending on whether you can pass an argument to the method to be executed:

  • Se il metodo non dispone di argomenti, si passa un ThreadStart delegato al costruttore.If the method has no arguments, you pass a ThreadStart delegate to the constructor. Ha la firma:It has the signature:

    public delegate void ThreadStart()  
    
    Public Delegate Sub ThreadStart()  
    

    Nell'esempio seguente crea e avvia un thread che esegue il ExecuteInForeground (metodo).The following example creates and starts a thread that executes the ExecuteInForeground method. Il metodo visualizza informazioni su alcune proprietà dei thread, quindi esegue un ciclo in cui viene sospeso per mezzo secondo e visualizza il numero di secondi trascorsi.The method displays information about some thread properties, then executes a loop in which it pauses for half a second and displays the elapsed number of seconds. Quando il thread è stato eseguito per almeno cinque secondi, il ciclo termina e il thread termina l'esecuzione.When the thread has executed for at least five seconds, the loop ends and the thread terminates execution.

    using System;
    using System.Diagnostics;
    using System.Threading;
    
    public class Example
    {
       public static void Main()
       {
          var th = new Thread(ExecuteInForeground);
          th.Start();
          Thread.Sleep(1000);
          Console.WriteLine("Main thread ({0}) exiting...", 
                            Thread.CurrentThread.ManagedThreadId); 
       }
       
       private static void ExecuteInForeground()
       {
          DateTime start = DateTime.Now;
          var sw = Stopwatch.StartNew();
          Console.WriteLine("Thread {0}: {1}, Priority {2}", 
                            Thread.CurrentThread.ManagedThreadId,
                            Thread.CurrentThread.ThreadState,
                            Thread.CurrentThread.Priority);
          do { 
             Console.WriteLine("Thread {0}: Elapsed {1:N2} seconds", 
                               Thread.CurrentThread.ManagedThreadId,
                               sw.ElapsedMilliseconds / 1000.0);
             Thread.Sleep(500);
          } while (sw.ElapsedMilliseconds <= 5000);
          sw.Stop(); 
       }
    }
    // The example displays output like the following:
    //       Thread 3: Running, Priority Normal
    //       Thread 3: Elapsed 0.00 seconds
    //       Thread 3: Elapsed 0.51 seconds
    //       Main thread (1) exiting...
    //       Thread 3: Elapsed 1.02 seconds
    //       Thread 3: Elapsed 1.53 seconds
    //       Thread 3: Elapsed 2.05 seconds
    //       Thread 3: Elapsed 2.55 seconds
    //       Thread 3: Elapsed 3.07 seconds
    //       Thread 3: Elapsed 3.57 seconds
    //       Thread 3: Elapsed 4.07 seconds
    //       Thread 3: Elapsed 4.58 seconds
    
    Imports System.Diagnostics
    Imports System.Threading
    
    Module Example
       Public Sub Main()
          Dim th As New Thread(AddressOf ExecuteInForeground)
          th.Start()
          Thread.Sleep(1000)
          Console.WriteLine("Main thread ({0}) exiting...", Thread.CurrentThread.ManagedThreadId) 
       End Sub
       
       Private Sub ExecuteInForeground()
          Dim start As DateTime = DateTime.Now
          Dim sw As Stopwatch = Stopwatch.StartNew()
          Console.WriteLine("Thread {0}: {1}, Priority {2}", 
                            Thread.CurrentThread.ManagedThreadId,
                            Thread.CurrentThread.ThreadState,
                            Thread.CurrentThread.Priority)
          Do 
             Console.WriteLine("Thread {0}: Elapsed {1:N2} seconds", 
                               Thread.CurrentThread.ManagedThreadId,
                               sw.ElapsedMilliseconds / 1000)
             Thread.Sleep(500)
          Loop While sw.ElapsedMilliseconds <= 5000
          sw.Stop() 
       End Sub
    End Module
    ' The example displays output like the following:
    '       Thread 3: Running, Priority Normal
    '       Thread 3: Elapsed 0.00 seconds
    '       Thread 3: Elapsed 0.51 seconds
    '       Main thread (1) exiting...
    '       Thread 3: Elapsed 1.02 seconds
    '       Thread 3: Elapsed 1.53 seconds
    '       Thread 3: Elapsed 2.05 seconds
    '       Thread 3: Elapsed 2.55 seconds
    '       Thread 3: Elapsed 3.07 seconds
    '       Thread 3: Elapsed 3.57 seconds
    '       Thread 3: Elapsed 4.07 seconds
    '       Thread 3: Elapsed 4.58 seconds
    
  • Se il metodo ha un argomento, si passa un ParameterizedThreadStart delegato al costruttore.If the method has an argument, you pass a ParameterizedThreadStart delegate to the constructor. Ha la firma:It has the signature:

    public delegate void ParameterizedThreadStart(object obj)  
    
    Public Delegate Sub ParameterizedThreadStart(obj As Object)  
    

    Il metodo eseguito dal delegato può quindi eseguire il cast (in c#) o convertire (in Visual Basic) il parametro nel tipo appropriato.The method executed by the delegate can then cast (in C#) or convert (in Visual Basic) the parameter to the appropriate type.

    Nell'esempio seguente è identico a quello precedente, ad eccezione del fatto che chiami il Thread(ParameterizedThreadStart) costruttore.The following example is identical to the previous one, except that it calls the Thread(ParameterizedThreadStart) constructor. Questa versione del ExecuteInForeground metodo ha un singolo parametro che rappresenta il numero approssimativo di millisecondi il ciclo consiste nell'eseguire.This version of the ExecuteInForeground method has a single parameter that represents the approximate number of milliseconds the loop is to execute.

    using System;
    using System.Diagnostics;
    using System.Threading;
    
    public class Example
    {
       public static void Main()
       {
          var th = new Thread(ExecuteInForeground);
          th.Start(4500);
          Thread.Sleep(1000);
          Console.WriteLine("Main thread ({0}) exiting...", 
                            Thread.CurrentThread.ManagedThreadId); 
       }
       
       private static void ExecuteInForeground(Object obj)
       {
          int interval;
          try {
             interval = (int) obj;
          }
          catch (InvalidCastException) {
             interval = 5000;
          }
          DateTime start = DateTime.Now;
          var sw = Stopwatch.StartNew();
          Console.WriteLine("Thread {0}: {1}, Priority {2}", 
                            Thread.CurrentThread.ManagedThreadId,
                            Thread.CurrentThread.ThreadState,
                            Thread.CurrentThread.Priority);
          do { 
             Console.WriteLine("Thread {0}: Elapsed {1:N2} seconds", 
                               Thread.CurrentThread.ManagedThreadId,
                               sw.ElapsedMilliseconds / 1000.0);
             Thread.Sleep(500);
          } while (sw.ElapsedMilliseconds <= interval);
          sw.Stop(); 
       }
    }
    // The example displays output like the following:
    //       Thread 3: Running, Priority Normal
    //       Thread 3: Elapsed 0.00 seconds
    //       Thread 3: Elapsed 0.52 seconds
    //       Main thread (1) exiting...
    //       Thread 3: Elapsed 1.03 seconds
    //       Thread 3: Elapsed 1.55 seconds
    //       Thread 3: Elapsed 2.06 seconds
    //       Thread 3: Elapsed 2.58 seconds
    //       Thread 3: Elapsed 3.09 seconds
    //       Thread 3: Elapsed 3.61 seconds
    //       Thread 3: Elapsed 4.12 seconds
    
    Imports System.Diagnostics
    Imports System.Threading
    
    Module Example
       Public Sub Main()
          Dim th As New Thread(AddressOf ExecuteInForeground)
          th.Start(4500)
          Thread.Sleep(1000)
          Console.WriteLine("Main thread ({0}) exiting...", Thread.CurrentThread.ManagedThreadId) 
       End Sub
       
       Private Sub ExecuteInForeground(obj As Object)
          Dim interval As Integer
          If IsNumeric(obj) Then
             interval = CInt(obj)
          Else
             interval = 5000
          End If   
          Dim start As DateTime = DateTime.Now
          Dim sw As Stopwatch = Stopwatch.StartNew()
          Console.WriteLine("Thread {0}: {1}, Priority {2}", 
                            Thread.CurrentThread.ManagedThreadId,
                            Thread.CurrentThread.ThreadState,
                            Thread.CurrentThread.Priority)
          Do 
             Console.WriteLine("Thread {0}: Elapsed {1:N2} seconds", 
                               Thread.CurrentThread.ManagedThreadId,
                               sw.ElapsedMilliseconds / 1000)
             Thread.Sleep(500)
          Loop While sw.ElapsedMilliseconds <= interval
          sw.Stop() 
       End Sub
    End Module
    ' The example displays output like the following:
    '       Thread 3: Running, Priority Normal
    '       Thread 3: Elapsed 0.00 seconds
    '       Thread 3: Elapsed 0.52 seconds
    '       Main thread (1) exiting...
    '       Thread 3: Elapsed 1.03 seconds
    '       Thread 3: Elapsed 1.55 seconds
    '       Thread 3: Elapsed 2.06 seconds
    '       Thread 3: Elapsed 2.58 seconds
    '       Thread 3: Elapsed 3.09 seconds
    '       Thread 3: Elapsed 3.61 seconds
    '       Thread 3: Elapsed 4.12 seconds
    

Non è necessario conservare un riferimento a un Thread dopo aver avviato il thread dell'oggetto.It is not necessary to retain a reference to a Thread object once you have started the thread. Il thread continua l'esecuzione fino al termine della routine del thread.The thread continues to execute until the thread procedure is complete.

Recupero di oggetti ThreadRetrieving Thread objects

È possibile usare il metodo statico (Shared in Visual Basic) CurrentThread proprietà per recuperare un riferimento al thread attualmente in esecuzione dal codice che il thread è in esecuzione.You can use the static (Shared in Visual Basic) CurrentThread property to retrieve a reference to the currently executing thread from the code that the thread is executing. L'esempio seguente usa il CurrentThread proprietà per visualizzare informazioni sul thread dell'applicazione principale, un altro thread in primo piano, un thread in background e un pool di thread.The following example uses the CurrentThread property to display information about the main application thread, another foreground thread, a background thread, and a thread pool thread.

using System;
using System.Threading;

public class Example
{
   static Object obj = new Object();
   
   public static void Main()
   {
      ThreadPool.QueueUserWorkItem(ShowThreadInformation);
      var th1 = new Thread(ShowThreadInformation);
      th1.Start();
      var th2 = new Thread(ShowThreadInformation);
      th2.IsBackground = true;
      th2.Start();
      Thread.Sleep(500);
      ShowThreadInformation(null); 
   }
   
   private static void ShowThreadInformation(Object state)
   {
      lock (obj) {
         var th  = Thread.CurrentThread;
         Console.WriteLine("Managed thread #{0}: ", th.ManagedThreadId);
         Console.WriteLine("   Background thread: {0}", th.IsBackground);
         Console.WriteLine("   Thread pool thread: {0}", th.IsThreadPoolThread);
         Console.WriteLine("   Priority: {0}", th.Priority);
         Console.WriteLine("   Culture: {0}", th.CurrentCulture.Name);
         Console.WriteLine("   UI culture: {0}", th.CurrentUICulture.Name);
         Console.WriteLine();
      }   
   }
}
// The example displays output like the following:
//       Managed thread #6:
//          Background thread: True
//          Thread pool thread: False
//          Priority: Normal
//          Culture: en-US
//          UI culture: en-US
//       
//       Managed thread #3:
//          Background thread: True
//          Thread pool thread: True
//          Priority: Normal
//          Culture: en-US
//          UI culture: en-US
//       
//       Managed thread #4:
//          Background thread: False
//          Thread pool thread: False
//          Priority: Normal
//          Culture: en-US
//          UI culture: en-US
//       
//       Managed thread #1:
//          Background thread: False
//          Thread pool thread: False
//          Priority: Normal
//          Culture: en-US
//          UI culture: en-US
Imports System.Threading

Module Example
   Private lock As New Object()
                    
   Public Sub Main()
      ThreadPool.QueueUserWorkItem(AddressOf ShowThreadInformation)
      Dim th1 As New Thread(AddressOf ShowThreadInformation)
      th1.Start()
      Dim th2 As New Thread(AddressOf ShowThreadInformation)
      th2.IsBackground = True
      th2.Start()
      Thread.Sleep(500)
      ShowThreadInformation(Nothing) 
   End Sub
   
   Private Sub ShowThreadInformation(state As Object)
      SyncLock lock
         Dim th As Thread = Thread.CurrentThread
         Console.WriteLine("Managed thread #{0}: ", th.ManagedThreadId)
         Console.WriteLine("   Background thread: {0}", th.IsBackground)
         Console.WriteLine("   Thread pool thread: {0}", th.IsThreadPoolThread)
         Console.WriteLine("   Priority: {0}", th.Priority)
         Console.WriteLine("   Culture: {0}", th.CurrentCulture.Name)
         Console.WriteLine("   UI culture: {0}", th.CurrentUICulture.Name)
         Console.WriteLine()
      End SyncLock
   End Sub
End Module
' The example displays output like the following:
'       ' Managed thread #6:
'          Background thread: True
'          Thread pool thread: False
'          Priority: Normal
'          Culture: en-US
'          UI culture: en-US
'       
'       Managed thread #3:
'          Background thread: True
'          Thread pool thread: True
'          Priority: Normal
'          Culture: en-US
'          UI culture: en-US
'       
'       Managed thread #4:
'          Background thread: False
'          Thread pool thread: False
'          Priority: Normal
'          Culture: en-US
'          UI culture: en-US
'       
'       Managed thread #1:
'          Background thread: False
'          Thread pool thread: False
'          Priority: Normal
'          Culture: en-US
'          UI culture: en-US

Thread in primo piano e sfondoForeground and background threads

Le istanze del Thread classe rappresentano i thread in primo piano o thread in background.Instances of the Thread class represent either foreground threads or background threads. I thread in background sono identici ai thread in primo piano con una sola eccezione: un thread in background non mantiene un processo in esecuzione se tutti i thread in primo piano sono terminati.Background threads are identical to foreground threads with one exception: a background thread does not keep a process running if all foreground threads have terminated. Una volta arrestati tutti i thread in primo piano, il runtime arresta tutti i thread in background e viene terminato.Once all foreground threads have been stopped, the runtime stops all background threads and shuts down.

Per impostazione predefinita, i thread seguenti eseguire in primo piano:By default, the following threads execute in the foreground:

  • Il thread principale dell'applicazione.The main application thread.

  • Tutti i thread creati chiamando un Thread costruttore della classe.All threads created by calling a Thread class constructor.

Eseguire i thread seguenti in background per impostazione predefinita:The following threads execute in the background by default:

  • Thread del pool di thread, costituiti da un pool di thread di lavoro gestiti dal runtime.Thread pool threads, which are a pool of worker threads maintained by the runtime. È possibile configurare il lavoro del pool e la pianificazione del thread nel pool di thread usando il ThreadPool classe.You can configure the thread pool and schedule work on thread pool threads by using the ThreadPool class.

    Nota

    Eseguire automaticamente operazioni asincrone basate su attività nel pool di thread.Task-based asynchronous operations automatically execute on thread pool threads. Operazioni asincrone basate su attività usano il Task e Task<TResult> classi per implementare le modello asincrono basato su attività.Task-based asynchronous operations use the Task and Task<TResult> classes to implement the task-based asynchronous pattern.

  • Tutti i thread che accedono all'ambiente di esecuzione gestita dal codice non gestito.All threads that enter the managed execution environment from unmanaged code.

È possibile modificare un thread per l'esecuzione in background mediante l'impostazione di IsBackground proprietà in qualsiasi momento.You can change a thread to execute in the background by setting the IsBackground property at any time. I thread in background sono utili per qualsiasi operazione che deve continuare fino a quando un'applicazione è in esecuzione ma non dovrebbe impedire l'applicazione da terminare il programma, ad esempio il monitoraggio delle modifiche al file system o le connessioni socket in ingresso.Background threads are useful for any operation that should continue as long as an application is running but should not prevent the application from terminating, such as monitoring file system changes or incoming socket connections.

Nell'esempio seguente viene illustrata la differenza tra i thread in primo piano e sfondo.The following example illustrates the difference between foreground and background threads. È, ad esempio nel primo esempio il avvio di un thread sezione, ad eccezione del fatto che imposta il thread per l'esecuzione in background prima di avviarla.It is like the first example in the Starting a thread section, except that it sets the thread to execute in the background before starting it. Come illustrato nell'output, il ciclo viene interrotto prima dell'esecuzione per cinque secondi.As the output shows, the loop is interrupted before it executes for five seconds.

using System;
using System.Diagnostics;
using System.Threading;

public class Example
{
   public static void Main()
   {
      var th = new Thread(ExecuteInForeground);
      th.IsBackground = true;
      th.Start();
      Thread.Sleep(1000);
      Console.WriteLine("Main thread ({0}) exiting...", 
                        Thread.CurrentThread.ManagedThreadId); 
   }
   
   private static void ExecuteInForeground()
   {
      DateTime start = DateTime.Now;
      var sw = Stopwatch.StartNew();
      Console.WriteLine("Thread {0}: {1}, Priority {2}", 
                        Thread.CurrentThread.ManagedThreadId,
                        Thread.CurrentThread.ThreadState,
                        Thread.CurrentThread.Priority);
      do { 
         Console.WriteLine("Thread {0}: Elapsed {1:N2} seconds", 
                           Thread.CurrentThread.ManagedThreadId,
                           sw.ElapsedMilliseconds / 1000.0);
         Thread.Sleep(500);
      } while (sw.ElapsedMilliseconds <= 5000);
      sw.Stop(); 
   }
}
// The example displays output like the following:
//       Thread 3: Background, Priority Normal
//       Thread 3: Elapsed 0.00 seconds
//       Thread 3: Elapsed 0.51 seconds
//       Main thread (1) exiting...
Imports System.Diagnostics
Imports System.Threading

Module Example
   Public Sub Main()
      Dim th As New Thread(AddressOf ExecuteInForeground)
      th.IsBackground = True
      th.Start()
      Thread.Sleep(1000)
      Console.WriteLine("Main thread ({0}) exiting...", Thread.CurrentThread.ManagedThreadId) 
   End Sub
   
   Private Sub ExecuteInForeground()
      Dim start As DateTime = DateTime.Now
      Dim sw As Stopwatch = Stopwatch.StartNew()
      Console.WriteLine("Thread {0}: {1}, Priority {2}", 
                        Thread.CurrentThread.ManagedThreadId,
                        Thread.CurrentThread.ThreadState,
                        Thread.CurrentThread.Priority)
      Do 
         Console.WriteLine("Thread {0}: Elapsed {1:N2} seconds", 
                           Thread.CurrentThread.ManagedThreadId,
                           sw.ElapsedMilliseconds / 1000)
         Thread.Sleep(500)
      Loop While sw.ElapsedMilliseconds <= 5000
      sw.Stop() 
   End Sub
End Module
' The example displays output like the following:
'       Thread 3: Background, Priority Normal
'       Thread 3: Elapsed 0.00 seconds
'       Thread 3: Elapsed 0.51 seconds
'       Main thread (1) exiting...

Impostazioni cultura e threadCulture and threads

Ogni thread dispone di impostazioni cultura, rappresentate dal CurrentCulture proprietà e impostazioni cultura dell'interfaccia utente, rappresentato dal CurrentUICulture proprietà.Each thread has a culture, represented by the CurrentCulture property, and a UI culture, represented by the CurrentUICulture property. Le impostazioni cultura correnti supporta operazioni dipendenti dalle impostazioni cultura quali l'analisi e formattazione, confronto tra stringhe e l'ordinamento e controlla anche il sistema di scrittura e il calendario usato da un thread.The current culture supports such culture-sensitive operations as parsing and formatting, string comparison and sorting, and also controls the writing system and calendar used by a thread. Le impostazioni cultura correnti dell'interfaccia utente fornisce per il recupero di distinzione delle impostazioni cultura delle risorse nei file di risorse.The current UI culture provides for culture-sensitive retrieval of resources in resource files.

Importante

Il CurrentCulture e CurrentUICulture proprietà non funzionano in modo affidabile quando usato con qualsiasi thread diverso da quello corrente.The CurrentCulture and CurrentUICulture properties don't work reliably when used with any thread other than the current thread. In .NET Framework, la lettura di queste proprietà è affidabile, anche se non è impostare queste proprietà per un thread diverso da quello corrente.In .NET Framework, reading these properties is reliable, although setting these properties for a thread other than the current thread is not. In .NET Core, un InvalidOperationException viene generata se un thread tenta di leggere o scrivere queste proprietà in un thread diverso.On .NET Core, an InvalidOperationException is thrown if a thread attempts to read or write these properties on a different thread. È consigliabile usare la CultureInfo.CurrentCulture e CultureInfo.CurrentUICulture proprietà da recuperare e impostare le impostazioni cultura correnti.We recommend that you use the CultureInfo.CurrentCulture and CultureInfo.CurrentUICulture properties to retrieve and set the current culture.

Quando viene creata un'istanza di un nuovo thread, le impostazioni cultura e le impostazioni cultura dell'interfaccia utente vengono definiti dalle impostazioni cultura correnti del sistema e delle impostazioni cultura dell'interfaccia utente e non per le impostazioni cultura e le impostazioni cultura dell'interfaccia utente del thread da cui viene creato il nuovo thread.When a new thread is instantiated, its culture and UI culture are defined by the current system culture and UI culture, and not by the culture and UI culture of the thread from which the new thread is created. Ciò significa, ad esempio, che se le impostazioni cultura correnti del sistema sono l'inglese (Stati Uniti) e le impostazioni cultura correnti del thread principale dell'applicazione sono il francese (Francia), le impostazioni cultura di un nuovo thread creato mediante la chiamata di Thread(ParameterizedThreadStart) costruttore dal thread principale è inglese (Stati Uniti) e non francese (Francia).This means, for example, that if the current system culture is English (United States) and the current culture of the primary application thread is French (France), the culture of a new thread created by calling the Thread(ParameterizedThreadStart) constructor from the primary thread is English (United States), and not French (France). Per altre informazioni, vedere la sezione "Impostazioni cultura e thread" del CultureInfo argomento relativo alla classe.For more information, see the "Culture and threads" section of the CultureInfo class topic.

Importante

Ciò non è possibile di thread che eseguono operazioni asincrone per le app che hanno come destinazione il .NET Framework 4.6.NET Framework 4.6 e versioni successive, In questo caso, le impostazioni cultura e le impostazioni cultura dell'interfaccia utente è parte di un'asincrona contesto operazioni, il thread in cui un'operazione asincrona esegue l'istruzione con predefinito eredita le impostazioni cultura e le impostazioni cultura dell'interfaccia utente del thread da cui è stata avviata l'operazione asincrona.This is not true of threads that execute asynchronous operations for apps that target the .NET Framework 4.6.NET Framework 4.6 and later versions, In this case, the culture and UI culture is part of an asynchronous operations' context; the thread on which an asynchronous operation executes by default inherits the culture and UI culture of the thread from which the asynchronous operation was launched. Per altre informazioni, vedere la sezione dedicata alle impostazioni cultura e alle operazioni asincrone basate su attività nell'argomento relativo alla classe CultureInfo.For more information, see the "Culture and task-based asynchronous operations" section of the CultureInfo class topic.

È possibile effettuare una delle operazioni seguenti per assicurarsi che tutti i thread in esecuzione in un'applicazione condividono le stesse impostazioni cultura e le impostazioni cultura dell'interfaccia utente:You can do either of the following to ensure that all of the threads executing in an application share the same culture and UI culture:

Per altre informazioni ed esempi, vedere la sezione "Impostazioni cultura e thread" del CultureInfo argomento relativo alla classe.For more information and examples, see the "Culture and threads" section of the CultureInfo class topic.

Recupero di informazioni e controllo di threadGetting information about and controlling threads

È possibile recuperare un numero di valori di proprietà che forniscono informazioni su un thread.You can retrieve a number of property values that provide information about a thread. In alcuni casi, è anche possibile impostare questi valori di proprietà per controllare l'operazione del thread.In some cases, you can also set these property values to control the operation of the thread. Queste proprietà thread includono:These thread properties include:

  • Un nomeA name. Name è un'operazione di scrittura-proprietà di una volta che è possibile usare per identificare un thread.Name is a write-once property that you can use to identify a thread. Il valore predefinito è null.Its default value is null.

  • Un codice hash, che è possibile recuperare tramite una chiamata di GetHashCode (metodo).A hash code, which you can retrieve by calling the GetHashCode method. Il codice hash può essere utilizzato per identificare in modo univoco un thread. per la durata del thread, il codice hash non entrerà in conflitto con il valore da un altro thread, indipendentemente dal dominio dell'applicazione da cui ottenere il valore.The hash code can be used to uniquely identify a thread; for the lifetime of your thread, its hash code will not collide with the value from any other thread, regardless of the application domain from which you obtain the value.

  • Un ID del thread.A thread ID. Il valore di sola lettura ManagedThreadId proprietà viene assegnata dal runtime e identifica in modo univoco un thread all'interno di un processo.The value of the read-only ManagedThreadId property is assigned by the runtime and uniquely identifies a thread within its process.

    Nota

    L'oggetto ThreadId di un sistema operativo non ha una relazione fissa con un thread gestito, perché un host non gestito può controllare la relazione tra thread gestiti e non gestiti.An operating-system ThreadId has no fixed relationship to a managed thread, because an unmanaged host can control the relationship between managed and unmanaged threads. In particolare, un host sofisticato può usare la API Hosting CLR per pianificare molti thread gestiti sullo stesso thread del sistema operativo o spostare un thread gestito tra thread del sistema operativo diverso.Specifically, a sophisticated host can use the CLR Hosting API to schedule many managed threads against the same operating system thread, or to move a managed thread between different operating system threads.

  • Stato corrente del thread.The thread's current state. Per la durata della sua esistenza, un thread è sempre in uno o più degli stati definiti per il ThreadState proprietà.For the duration of its existence, a thread is always in one or more of the states defined by the ThreadState property.

  • Un livello di priorità di pianificazione, definito dal ThreadPriority proprietà.A scheduling priority level, which is defined by the ThreadPriority property. Sebbene sia possibile impostare questo valore per richiedere la priorità del thread, non è garantito a essere rispettato dal sistema operativo.Although you can set this value to request a thread's priority, it is not guaranteed to be honored by the operating system.

  • Di sola lettura IsThreadPoolThread proprietà, che indica se un thread è un pool di thread.The read-only IsThreadPoolThread property, which indicates whether a thread is a thread pool thread.

  • La proprietà IsBackground.The IsBackground property. Per altre informazioni, vedere la thread in primo piano e sfondo sezione.For more information, see the Foreground and background threads section.

Costruttori

Thread(ParameterizedThreadStart) Thread(ParameterizedThreadStart) Thread(ParameterizedThreadStart) Thread(ParameterizedThreadStart)

Inizializza una nuova istanza della classe Thread, specificando un delegato che consente di passare un oggetto al thread quando quest'ultimo viene avviato.Initializes a new instance of the Thread class, specifying a delegate that allows an object to be passed to the thread when the thread is started.

Thread(ParameterizedThreadStart, Int32) Thread(ParameterizedThreadStart, Int32) Thread(ParameterizedThreadStart, Int32) Thread(ParameterizedThreadStart, Int32)

Inizializza una nuova istanza della classe Thread, specificando un delegato che consente di passare un oggetto al thread quando quest'ultimo viene avviato e specificando la dimensione massima dello stack per il thread.Initializes a new instance of the Thread class, specifying a delegate that allows an object to be passed to the thread when the thread is started and specifying the maximum stack size for the thread.

Thread(ThreadStart) Thread(ThreadStart) Thread(ThreadStart) Thread(ThreadStart)

Inizializza una nuova istanza della classe Thread.Initializes a new instance of the Thread class.

Thread(ThreadStart, Int32) Thread(ThreadStart, Int32) Thread(ThreadStart, Int32) Thread(ThreadStart, Int32)

Inizializza una nuova istanza della classe Thread, specificando la dimensione massima dello stack per il thread.Initializes a new instance of the Thread class, specifying the maximum stack size for the thread.

Proprietà

ApartmentState ApartmentState ApartmentState ApartmentState

Ottiene o imposta lo stato dell'apartment del thread.Gets or sets the apartment state of this thread.

CurrentContext CurrentContext CurrentContext CurrentContext

Ottiene il contesto corrente in cui è in esecuzione il thread.Gets the current context in which the thread is executing.

CurrentCulture CurrentCulture CurrentCulture CurrentCulture

Ottiene o imposta le impostazioni cultura per il thread corrente.Gets or sets the culture for the current thread.

CurrentPrincipal CurrentPrincipal CurrentPrincipal CurrentPrincipal

Ottiene o imposta l'entità corrente del thread (per la sicurezza basata sui ruoli).Gets or sets the thread's current principal (for role-based security).

CurrentThread CurrentThread CurrentThread CurrentThread

Ottiene il thread attualmente in esecuzione.Gets the currently running thread.

CurrentUICulture CurrentUICulture CurrentUICulture CurrentUICulture

Ottiene o imposta le impostazioni cultura correnti usate da Gestione risorse per cercare le risorse specifiche delle impostazioni cultura in fase di esecuzione.Gets or sets the current culture used by the Resource Manager to look up culture-specific resources at run time.

ExecutionContext ExecutionContext ExecutionContext ExecutionContext

Ottiene un oggetto ExecutionContext contenente informazioni sui diversi contesti del thread corrente.Gets an ExecutionContext object that contains information about the various contexts of the current thread.

IsAlive IsAlive IsAlive IsAlive

Ottiene un valore che indica lo stato di esecuzione del thread corrente.Gets a value indicating the execution status of the current thread.

IsBackground IsBackground IsBackground IsBackground

Ottiene o imposta un valore che indica se il thread viene eseguito in background.Gets or sets a value indicating whether or not a thread is a background thread.

IsThreadPoolThread IsThreadPoolThread IsThreadPoolThread IsThreadPoolThread

Ottiene un valore che indica se un thread appartiene o meno al pool di thread gestiti.Gets a value indicating whether or not a thread belongs to the managed thread pool.

ManagedThreadId ManagedThreadId ManagedThreadId ManagedThreadId

Ottiene un identificatore univoco per il thread gestito corrente.Gets a unique identifier for the current managed thread.

Name Name Name Name

Ottiene o imposta il nome del thread.Gets or sets the name of the thread.

Priority Priority Priority Priority

Ottiene o imposta un valore che indica la priorità di pianificazione di un thread.Gets or sets a value indicating the scheduling priority of a thread.

ThreadState ThreadState ThreadState ThreadState

Ottiene un valore contenente gli stati del thread corrente.Gets a value containing the states of the current thread.

Metodi

Abort() Abort() Abort() Abort()

Genera un'eccezione ThreadAbortException nel thread in cui viene richiamato, per iniziare il processo di terminazione del thread.Raises a ThreadAbortException in the thread on which it is invoked, to begin the process of terminating the thread. La chiamata a questo metodo in genere termina il thread.Calling this method usually terminates the thread.

Abort(Object) Abort(Object) Abort(Object) Abort(Object)

Genera un'eccezione ThreadAbortException nel thread in cui viene richiamato per iniziare il processo di terminazione del thread fornendo anche informazioni sull'eccezione relative alla terminazione del thread.Raises a ThreadAbortException in the thread on which it is invoked, to begin the process of terminating the thread while also providing exception information about the thread termination. La chiamata a questo metodo in genere termina il thread.Calling this method usually terminates the thread.

AllocateDataSlot() AllocateDataSlot() AllocateDataSlot() AllocateDataSlot()

Alloca uno slot di dati senza nome su tutti i thread.Allocates an unnamed data slot on all the threads. Per ottenere prestazioni migliori, usare i campi contrassegnati con l'attributo ThreadStaticAttribute.For better performance, use fields that are marked with the ThreadStaticAttribute attribute instead.

AllocateNamedDataSlot(String) AllocateNamedDataSlot(String) AllocateNamedDataSlot(String) AllocateNamedDataSlot(String)

Alloca uno slot di dati denominato su tutti i thread.Allocates a named data slot on all threads. Per ottenere prestazioni migliori, usare i campi contrassegnati con l'attributo ThreadStaticAttribute.For better performance, use fields that are marked with the ThreadStaticAttribute attribute instead.

BeginCriticalRegion() BeginCriticalRegion() BeginCriticalRegion() BeginCriticalRegion()

Notifica a un host che l'esecuzione sta per entrare in un'area di codice in cui gli effetti di un'interruzione del thread o di un'eccezione non gestita possono rappresentare un rischio per altre attività nel dominio applicazione.Notifies a host that execution is about to enter a region of code in which the effects of a thread abort or unhandled exception might jeopardize other tasks in the application domain.

BeginThreadAffinity() BeginThreadAffinity() BeginThreadAffinity() BeginThreadAffinity()

Notifica a un host che il codice gestito sta per eseguire istruzioni che dipendono dall'identità del thread fisico corrente del sistema operativo.Notifies a host that managed code is about to execute instructions that depend on the identity of the current physical operating system thread.

DisableComObjectEagerCleanup() DisableComObjectEagerCleanup() DisableComObjectEagerCleanup() DisableComObjectEagerCleanup()

Disattiva la pulizia automatica dei Runtime Callable Wrapper (RCW) per il thread corrente.Turns off automatic cleanup of runtime callable wrappers (RCW) for the current thread.

EndCriticalRegion() EndCriticalRegion() EndCriticalRegion() EndCriticalRegion()

Notifica a un host che l'esecuzione sta per entrare in un'area di codice in cui gli effetti di un'interruzione del thread o di un'eccezione non gestita sono limitati all'attività corrente.Notifies a host that execution is about to enter a region of code in which the effects of a thread abort or unhandled exception are limited to the current task.

EndThreadAffinity() EndThreadAffinity() EndThreadAffinity() EndThreadAffinity()

Notifica a un host che il codice gestito ha terminato l'esecuzione di istruzioni che dipendono dall'identità del thread fisico corrente del sistema operativo.Notifies a host that managed code has finished executing instructions that depend on the identity of the current physical operating system thread.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente.Determines whether the specified object is equal to the current object.

(Inherited from Object)
Finalize() Finalize() Finalize() Finalize()

Garantisce che le risorse vengano liberate e che vengano eseguite le altre operazioni di pulizia quando l'oggetto Thread viene recuperato da Garbage Collector.Ensures that resources are freed and other cleanup operations are performed when the garbage collector reclaims the Thread object.

FreeNamedDataSlot(String) FreeNamedDataSlot(String) FreeNamedDataSlot(String) FreeNamedDataSlot(String)

Elimina l'associazione tra un nome e uno slot per tutti i thread del processo.Eliminates the association between a name and a slot, for all threads in the process. Per ottenere prestazioni migliori, usare i campi contrassegnati con l'attributo ThreadStaticAttribute.For better performance, use fields that are marked with the ThreadStaticAttribute attribute instead.

GetApartmentState() GetApartmentState() GetApartmentState() GetApartmentState()

Restituisce un valore ApartmentState che indica lo stato dell'apartment.Returns an ApartmentState value indicating the apartment state.

GetCompressedStack() GetCompressedStack() GetCompressedStack() GetCompressedStack()

Restituisce un oggetto CompressedStack che può essere usato per acquisire lo stack per il thread corrente.Returns a CompressedStack object that can be used to capture the stack for the current thread.

GetCurrentProcessorId() GetCurrentProcessorId() GetCurrentProcessorId() GetCurrentProcessorId()
GetData(LocalDataStoreSlot) GetData(LocalDataStoreSlot) GetData(LocalDataStoreSlot) GetData(LocalDataStoreSlot)

Recupera il valore dallo slot specificato sul thread corrente, all'interno del dominio corrente del thread corrente.Retrieves the value from the specified slot on the current thread, within the current thread's current domain. Per ottenere prestazioni migliori, usare i campi contrassegnati con l'attributo ThreadStaticAttribute.For better performance, use fields that are marked with the ThreadStaticAttribute attribute instead.

GetDomain() GetDomain() GetDomain() GetDomain()

Restituisce il dominio corrente in cui viene eseguito il thread corrente.Returns the current domain in which the current thread is running.

GetDomainID() GetDomainID() GetDomainID() GetDomainID()

Restituisce un identificatore di dominio applicazione univoco.Returns a unique application domain identifier.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Restituisce un codice hash per il thread corrente.Returns a hash code for the current thread.

GetNamedDataSlot(String) GetNamedDataSlot(String) GetNamedDataSlot(String) GetNamedDataSlot(String)

Cerca uno slot di dati denominato.Looks up a named data slot. Per ottenere prestazioni migliori, usare i campi contrassegnati con l'attributo ThreadStaticAttribute.For better performance, use fields that are marked with the ThreadStaticAttribute attribute instead.

GetType() GetType() GetType() GetType()

Ottiene l'oggetto Type dell'istanza corrente.Gets the Type of the current instance.

(Inherited from Object)
Interrupt() Interrupt() Interrupt() Interrupt()

Interrompe un thread il cui stato è WaitSleepJoin.Interrupts a thread that is in the WaitSleepJoin thread state.

Join() Join() Join() Join()

Blocca il thread chiamante finché non termina il thread rappresentato da questa istanza, pur continuando a eseguire la distribuzione di SendMessage e COM standard.Blocks the calling thread until the thread represented by this instance terminates, while continuing to perform standard COM and SendMessage pumping.

Join(Int32) Join(Int32) Join(Int32) Join(Int32)

Blocca il thread chiamante finché non termina il thread rappresentato da questa istanza o finché non trascorre l'intervallo di tempo specificato, pur continuando a eseguire la distribuzione di SendMessage e COM standard.Blocks the calling thread until the thread represented by this instance terminates or the specified time elapses, while continuing to perform standard COM and SendMessage pumping.

Join(TimeSpan) Join(TimeSpan) Join(TimeSpan) Join(TimeSpan)

Blocca il thread chiamante finché non termina il thread rappresentato da questa istanza o finché non trascorre l'intervallo di tempo specificato, pur continuando a eseguire la distribuzione di SendMessage e COM standard.Blocks the calling thread until the thread represented by this instance terminates or the specified time elapses, while continuing to perform standard COM and SendMessage pumping.

MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.Creates a shallow copy of the current Object.

(Inherited from Object)
MemoryBarrier() MemoryBarrier() MemoryBarrier() MemoryBarrier()

Sincronizza l'accesso alla memoria nel modo seguente: il processore che esegue il thread corrente non può riordinare le istruzioni in modo tale che gli accessi alla memoria prima della chiamata al metodo MemoryBarrier() vengano eseguiti dopo quelli successivi alla chiamata al metodo MemoryBarrier().Synchronizes memory access as follows: The processor executing the current thread cannot reorder instructions in such a way that memory accesses prior to the call to MemoryBarrier() execute after memory accesses that follow the call to MemoryBarrier().

ResetAbort() ResetAbort() ResetAbort() ResetAbort()

Annulla il metodo Abort(Object) richiesto per il thread corrente.Cancels an Abort(Object) requested for the current thread.

Resume() Resume() Resume() Resume()

Riprende un thread che era stato sospeso.Resumes a thread that has been suspended.

SetApartmentState(ApartmentState) SetApartmentState(ApartmentState) SetApartmentState(ApartmentState) SetApartmentState(ApartmentState)

Imposta lo stato dell'apartment di un thread prima che venga avviato.Sets the apartment state of a thread before it is started.

SetCompressedStack(CompressedStack) SetCompressedStack(CompressedStack) SetCompressedStack(CompressedStack) SetCompressedStack(CompressedStack)

Applica un oggetto CompressedStack acquisito al thread corrente.Applies a captured CompressedStack to the current thread.

SetData(LocalDataStoreSlot, Object) SetData(LocalDataStoreSlot, Object) SetData(LocalDataStoreSlot, Object) SetData(LocalDataStoreSlot, Object)

Imposta i dati nello slot specificato sul thread in esecuzione per il dominio corrente di tale thread.Sets the data in the specified slot on the currently running thread, for that thread's current domain. Per ottenere prestazioni migliori, usare i campi contrassegnati con l'attributo ThreadStaticAttribute.For better performance, use fields marked with the ThreadStaticAttribute attribute instead.

Sleep(Int32) Sleep(Int32) Sleep(Int32) Sleep(Int32)

Sospende il thread corrente per il numero specificato di millisecondi.Suspends the current thread for the specified number of milliseconds.

Sleep(TimeSpan) Sleep(TimeSpan) Sleep(TimeSpan) Sleep(TimeSpan)

Sospende il thread corrente per il periodo di tempo specificato.Suspends the current thread for the specified amount of time.

SpinWait(Int32) SpinWait(Int32) SpinWait(Int32) SpinWait(Int32)

Determina che un thread rimanga in attesa il numero di volte definito dal parametro iterations.Causes a thread to wait the number of times defined by the iterations parameter.

Start() Start() Start() Start()

Determina il cambiamento da parte del sistema operativo dello stato dell'istanza corrente in Running.Causes the operating system to change the state of the current instance to Running.

Start(Object) Start(Object) Start(Object) Start(Object)

Determina il cambiamento da parte del sistema operativo dello stato dell'istanza corrente in Running e, facoltativamente, fornisce un oggetto contenente i dati che devono essere usati dal metodo eseguito dal thread.Causes the operating system to change the state of the current instance to Running, and optionally supplies an object containing data to be used by the method the thread executes.

Suspend() Suspend() Suspend() Suspend()

Sospende il thread o, se il thread è già sospeso, non avrà alcun effetto.Either suspends the thread, or if the thread is already suspended, has no effect.

ToString() ToString() ToString() ToString()

Restituisce una stringa che rappresenta l'oggetto corrente.Returns a string that represents the current object.

(Inherited from Object)
TrySetApartmentState(ApartmentState) TrySetApartmentState(ApartmentState) TrySetApartmentState(ApartmentState) TrySetApartmentState(ApartmentState)

Imposta lo stato dell'apartment di un thread prima che venga avviato.Sets the apartment state of a thread before it is started.

VolatileRead(Byte) VolatileRead(Byte) VolatileRead(Byte) VolatileRead(Byte)

Legge il valore di un campo.Reads the value of a field. Tale valore è l'ultimo che è stato scritto da un processore qualsiasi in un computer, indipendentemente dal numero di processori o dallo stato della cache del processore.The value is the latest written by any processor in a computer, regardless of the number of processors or the state of processor cache.

VolatileRead(Double) VolatileRead(Double) VolatileRead(Double) VolatileRead(Double)

Legge il valore di un campo.Reads the value of a field. Tale valore è l'ultimo che è stato scritto da un processore qualsiasi in un computer, indipendentemente dal numero di processori o dallo stato della cache del processore.The value is the latest written by any processor in a computer, regardless of the number of processors or the state of processor cache.

VolatileRead(Int16) VolatileRead(Int16) VolatileRead(Int16) VolatileRead(Int16)

Legge il valore di un campo.Reads the value of a field. Tale valore è l'ultimo che è stato scritto da un processore qualsiasi in un computer, indipendentemente dal numero di processori o dallo stato della cache del processore.The value is the latest written by any processor in a computer, regardless of the number of processors or the state of processor cache.

VolatileRead(Int32) VolatileRead(Int32) VolatileRead(Int32) VolatileRead(Int32)

Legge il valore di un campo.Reads the value of a field. Tale valore è l'ultimo che è stato scritto da un processore qualsiasi in un computer, indipendentemente dal numero di processori o dallo stato della cache del processore.The value is the latest written by any processor in a computer, regardless of the number of processors or the state of processor cache.

VolatileRead(Int64) VolatileRead(Int64) VolatileRead(Int64) VolatileRead(Int64)

Legge il valore di un campo.Reads the value of a field. Tale valore è l'ultimo che è stato scritto da un processore qualsiasi in un computer, indipendentemente dal numero di processori o dallo stato della cache del processore.The value is the latest written by any processor in a computer, regardless of the number of processors or the state of processor cache.

VolatileRead(IntPtr) VolatileRead(IntPtr) VolatileRead(IntPtr) VolatileRead(IntPtr)

Legge il valore di un campo.Reads the value of a field. Tale valore è l'ultimo che è stato scritto da un processore qualsiasi in un computer, indipendentemente dal numero di processori o dallo stato della cache del processore.The value is the latest written by any processor in a computer, regardless of the number of processors or the state of processor cache.

VolatileRead(Object) VolatileRead(Object) VolatileRead(Object) VolatileRead(Object)

Legge il valore di un campo.Reads the value of a field. Tale valore è l'ultimo che è stato scritto da un processore qualsiasi in un computer, indipendentemente dal numero di processori o dallo stato della cache del processore.The value is the latest written by any processor in a computer, regardless of the number of processors or the state of processor cache.

VolatileRead(SByte) VolatileRead(SByte) VolatileRead(SByte) VolatileRead(SByte)

Legge il valore di un campo.Reads the value of a field. Tale valore è l'ultimo che è stato scritto da un processore qualsiasi in un computer, indipendentemente dal numero di processori o dallo stato della cache del processore.The value is the latest written by any processor in a computer, regardless of the number of processors or the state of processor cache.

VolatileRead(Single) VolatileRead(Single) VolatileRead(Single) VolatileRead(Single)

Legge il valore di un campo.Reads the value of a field. Tale valore è l'ultimo che è stato scritto da un processore qualsiasi in un computer, indipendentemente dal numero di processori o dallo stato della cache del processore.The value is the latest written by any processor in a computer, regardless of the number of processors or the state of processor cache.

VolatileRead(UInt16) VolatileRead(UInt16) VolatileRead(UInt16) VolatileRead(UInt16)

Legge il valore di un campo.Reads the value of a field. Tale valore è l'ultimo che è stato scritto da un processore qualsiasi in un computer, indipendentemente dal numero di processori o dallo stato della cache del processore.The value is the latest written by any processor in a computer, regardless of the number of processors or the state of processor cache.

VolatileRead(UInt32) VolatileRead(UInt32) VolatileRead(UInt32) VolatileRead(UInt32)

Legge il valore di un campo.Reads the value of a field. Tale valore è l'ultimo che è stato scritto da un processore qualsiasi in un computer, indipendentemente dal numero di processori o dallo stato della cache del processore.The value is the latest written by any processor in a computer, regardless of the number of processors or the state of processor cache.

VolatileRead(UInt64) VolatileRead(UInt64) VolatileRead(UInt64) VolatileRead(UInt64)

Legge il valore di un campo.Reads the value of a field. Tale valore è l'ultimo che è stato scritto da un processore qualsiasi in un computer, indipendentemente dal numero di processori o dallo stato della cache del processore.The value is the latest written by any processor in a computer, regardless of the number of processors or the state of processor cache.

VolatileRead(UIntPtr) VolatileRead(UIntPtr) VolatileRead(UIntPtr) VolatileRead(UIntPtr)

Legge il valore di un campo.Reads the value of a field. Tale valore è l'ultimo che è stato scritto da un processore qualsiasi in un computer, indipendentemente dal numero di processori o dallo stato della cache del processore.The value is the latest written by any processor in a computer, regardless of the number of processors or the state of processor cache.

VolatileWrite(Byte, Byte) VolatileWrite(Byte, Byte) VolatileWrite(Byte, Byte) VolatileWrite(Byte, Byte)

Scrive immediatamente un valore in un campo, in modo che tale valore possa essere visibile a tutti i processori nel computer.Writes a value to a field immediately, so that the value is visible to all processors in the computer.

VolatileWrite(Double, Double) VolatileWrite(Double, Double) VolatileWrite(Double, Double) VolatileWrite(Double, Double)

Scrive immediatamente un valore in un campo, in modo che tale valore possa essere visibile a tutti i processori nel computer.Writes a value to a field immediately, so that the value is visible to all processors in the computer.

VolatileWrite(Int16, Int16) VolatileWrite(Int16, Int16) VolatileWrite(Int16, Int16) VolatileWrite(Int16, Int16)

Scrive immediatamente un valore in un campo, in modo che tale valore possa essere visibile a tutti i processori nel computer.Writes a value to a field immediately, so that the value is visible to all processors in the computer.

VolatileWrite(Int32, Int32) VolatileWrite(Int32, Int32) VolatileWrite(Int32, Int32) VolatileWrite(Int32, Int32)

Scrive immediatamente un valore in un campo, in modo che tale valore possa essere visibile a tutti i processori nel computer.Writes a value to a field immediately, so that the value is visible to all processors in the computer.

VolatileWrite(Int64, Int64) VolatileWrite(Int64, Int64) VolatileWrite(Int64, Int64) VolatileWrite(Int64, Int64)

Scrive immediatamente un valore in un campo, in modo che tale valore possa essere visibile a tutti i processori nel computer.Writes a value to a field immediately, so that the value is visible to all processors in the computer.

VolatileWrite(IntPtr, IntPtr) VolatileWrite(IntPtr, IntPtr) VolatileWrite(IntPtr, IntPtr) VolatileWrite(IntPtr, IntPtr)

Scrive immediatamente un valore in un campo, in modo che tale valore possa essere visibile a tutti i processori nel computer.Writes a value to a field immediately, so that the value is visible to all processors in the computer.

VolatileWrite(Object, Object) VolatileWrite(Object, Object) VolatileWrite(Object, Object) VolatileWrite(Object, Object)

Scrive immediatamente un valore in un campo, in modo che tale valore possa essere visibile a tutti i processori nel computer.Writes a value to a field immediately, so that the value is visible to all processors in the computer.

VolatileWrite(SByte, SByte) VolatileWrite(SByte, SByte) VolatileWrite(SByte, SByte) VolatileWrite(SByte, SByte)

Scrive immediatamente un valore in un campo, in modo che tale valore possa essere visibile a tutti i processori nel computer.Writes a value to a field immediately, so that the value is visible to all processors in the computer.

VolatileWrite(Single, Single) VolatileWrite(Single, Single) VolatileWrite(Single, Single) VolatileWrite(Single, Single)

Scrive immediatamente un valore in un campo, in modo che tale valore possa essere visibile a tutti i processori nel computer.Writes a value to a field immediately, so that the value is visible to all processors in the computer.

VolatileWrite(UInt16, UInt16) VolatileWrite(UInt16, UInt16) VolatileWrite(UInt16, UInt16) VolatileWrite(UInt16, UInt16)

Scrive immediatamente un valore in un campo, in modo che tale valore possa essere visibile a tutti i processori nel computer.Writes a value to a field immediately, so that the value is visible to all processors in the computer.

VolatileWrite(UInt32, UInt32) VolatileWrite(UInt32, UInt32) VolatileWrite(UInt32, UInt32) VolatileWrite(UInt32, UInt32)

Scrive immediatamente un valore in un campo, in modo che tale valore possa essere visibile a tutti i processori nel computer.Writes a value to a field immediately, so that the value is visible to all processors in the computer.

VolatileWrite(UInt64, UInt64) VolatileWrite(UInt64, UInt64) VolatileWrite(UInt64, UInt64) VolatileWrite(UInt64, UInt64)

Scrive immediatamente un valore in un campo, in modo che tale valore possa essere visibile a tutti i processori nel computer.Writes a value to a field immediately, so that the value is visible to all processors in the computer.

VolatileWrite(UIntPtr, UIntPtr) VolatileWrite(UIntPtr, UIntPtr) VolatileWrite(UIntPtr, UIntPtr) VolatileWrite(UIntPtr, UIntPtr)

Scrive immediatamente un valore in un campo, in modo che tale valore possa essere visibile a tutti i processori nel computer.Writes a value to a field immediately, so that the value is visible to all processors in the computer.

Yield() Yield() Yield() Yield()

Determina che il thread chiamante ceda l'esecuzione a un altro thread pronto per l'esecuzione sul processore corrente.Causes the calling thread to yield execution to another thread that is ready to run on the current processor. Il sistema operativo seleziona il thread a cui cedere l'esecuzione.The operating system selects the thread to yield to.

Implementazioni dell'interfaccia esplicita

_Thread.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr) _Thread.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr) _Thread.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr) _Thread.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

Esegue il mapping di un set di nomi a un set corrispondente di ID dispatch.Maps a set of names to a corresponding set of dispatch identifiers.

_Thread.GetTypeInfo(UInt32, UInt32, IntPtr) _Thread.GetTypeInfo(UInt32, UInt32, IntPtr) _Thread.GetTypeInfo(UInt32, UInt32, IntPtr) _Thread.GetTypeInfo(UInt32, UInt32, IntPtr)

Recupera le informazioni sul tipo relative a un oggetto che può quindi essere usato per ottenere informazioni sul tipo relative a un'interfaccia.Retrieves the type information for an object, which can then be used to get the type information for an interface.

_Thread.GetTypeInfoCount(UInt32) _Thread.GetTypeInfoCount(UInt32) _Thread.GetTypeInfoCount(UInt32) _Thread.GetTypeInfoCount(UInt32)

Recupera il numero delle interfacce di informazioni sul tipo fornite da un oggetto (0 o 1).Retrieves the number of type information interfaces that an object provides (either 0 or 1).

_Thread.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr) _Thread.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr) _Thread.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr) _Thread.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Fornisce l'accesso a proprietà e metodi esposti da un oggetto.Provides access to properties and methods exposed by an object.

Si applica a

Thread safety

Questo tipo è thread-safe.This type is thread safe.

Vedi anche