ParameterizedThreadStart Delegato

Riferimento

Definizione

Spazio dei nomi:: System.Threading

Assembly:: System.Threading.Thread.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

Rappresenta il metodo eseguito in un oggetto Thread.

public delegate void ParameterizedThreadStart(System::Object ^ obj);

public delegate void ParameterizedThreadStart(object? obj);

[System.Runtime.InteropServices.ComVisible(false)]
public delegate void ParameterizedThreadStart(object obj);

public delegate void ParameterizedThreadStart(object obj);

type ParameterizedThreadStart = delegate of obj -> unit

[<System.Runtime.InteropServices.ComVisible(false)>]
type ParameterizedThreadStart = delegate of obj -> unit

Public Delegate Sub ParameterizedThreadStart(obj As Object)

Parametri

obj: Object

Oggetto che contiene i dati per la routine del thread.

Attributi: ComVisibleAttribute

Esempio

Nell'esempio di codice seguente viene usato un ParameterizedThreadStart delegato per eseguire un metodo statico e un metodo di istanza. Il primo ParameterizedThreadStart delegato è rappresentato dal metodo statico DoWork e il secondo è rappresentato dal metodo di istanza DoMoreWork . Entrambi i metodi corrispondono alla firma del ParameterizedThreadStart delegato, ovvero hanno un singolo parametro di tipo Object e non restituiscono un valore.

Nota

I compilatori Visual Basic e C# deducono il ParameterizedThreadStart delegato dalle firme dei DoWork metodi e DoMoreWork e chiamano il costruttore corretto. Non esiste quindi alcuna chiamata esplicita al costruttore nel codice.

using namespace System;
using namespace System::Threading;

namespace SystemThreadingExample
{
    public ref class Work
    {
    public:
        void StartThreads()
        {
            // Start a thread that calls a parameterized static method.
            Thread^ newThread = gcnew
                Thread(gcnew ParameterizedThreadStart(Work::DoWork));
            newThread->Start(42);
              
            // Start a thread that calls a parameterized instance method.
            Work^ someWork = gcnew Work;
            newThread = gcnew Thread(
                        gcnew ParameterizedThreadStart(someWork,
                        &Work::DoMoreWork));
            newThread->Start("The answer.");
        }

        static void DoWork(Object^ data)
        {
            Console::WriteLine("Static thread procedure. Data='{0}'", 
                data);
        }

        void DoMoreWork(Object^ data)
        {
            Console::WriteLine("Instance thread procedure. Data='{0}'", 
                data);
        }
    };
}

//Entry point of example application
int main()
{
    SystemThreadingExample::Work^ samplework = 
        gcnew SystemThreadingExample::Work();
    samplework->StartThreads();
}
// This example displays output like the following:
//       Static thread procedure. Data='42'
//       Instance thread procedure. Data='The answer.'

using System;
using System.Threading;

public class Work
{
    public static void Main()
    {
        // Start a thread that calls a parameterized static method.
        Thread newThread = new Thread(Work.DoWork);
        newThread.Start(42);

        // Start a thread that calls a parameterized instance method.
        Work w = new Work();
        newThread = new Thread(w.DoMoreWork);
        newThread.Start("The answer.");
    }
 
    public static void DoWork(object data)
    {
        Console.WriteLine("Static thread procedure. Data='{0}'",
            data);
    }

    public void DoMoreWork(object data)
    {
        Console.WriteLine("Instance thread procedure. Data='{0}'",
            data);
    }
}
// This example displays output like the following:
//       Static thread procedure. Data='42'
//       Instance thread procedure. Data='The answer.'

Imports System.Threading

Public Class Work
    Shared Sub Main()
        ' Start a thread that calls a parameterized static method.
        Dim newThread As New Thread(AddressOf Work.DoWork)
        newThread.Start(42)

        ' Start a thread that calls a parameterized instance method.
        Dim w As New Work()
        newThread = New Thread(AddressOf w.DoMoreWork)
        newThread.Start("The answer.")
    End Sub
 
    Public Shared Sub DoWork(ByVal data As Object)
        Console.WriteLine("Static thread procedure. Data='{0}'",
                          data)
    End Sub

    Public Sub DoMoreWork(ByVal data As Object) 
        Console.WriteLine("Instance thread procedure. Data='{0}'",
                          data)
    End Sub
End Class
' This example displays output like the following:
'    Static thread procedure. Data='42'
'    Instance thread procedure. Data='The answer.'

Commenti

Quando viene creato un thread gestito, il metodo eseguito nel thread è rappresentato da:

Delegato ThreadStart passato al Thread.Thread(ThreadStart) costruttore. Qualsiasi metodo che non dispone di parametri e che restituisce void in C# o è una Sub routine in Visual Basic può rappresentare il delegato.
Delegato ParameterizedThreadStart passato al Thread.Thread(ParameterizedThreadStart) costruttore. Qualsiasi metodo con un singolo parametro di tipo Object e che restituisce void in C# o è una routine Sub in Visual Basic può rappresentare il delegato.

Il thread non inizia l'esecuzione finché non viene chiamato il Thread.Start metodo . Il ThreadStart delegato o ParameterizedThreadStart viene richiamato sul thread e l'esecuzione inizia alla prima riga del metodo rappresentato dal delegato. Nel caso del ParameterizedThreadStart delegato, l'oggetto passato al Start(Object) metodo viene passato al delegato.

Nota

Visual Basic e gli utenti C# possono omettere il costruttore o ParameterizedThreadStart delegato durante la ThreadStart creazione di un thread. In Visual Basic usare l'operatore AddressOf quando si passa il Thread metodo al costruttore, Dim t As New Thread(AddressOf ThreadProc)ad esempio . In C#, specificare semplicemente il nome della routine del thread. Il compilatore seleziona il costruttore delegato corretto.

Nota

Quando si crea un delegato per un ParameterizedThreadStart metodo di istanza in C++, il primo parametro del costruttore è la variabile di istanza. Per un metodo statico, il primo parametro del costruttore è zero. Per un metodo statico, il costruttore delegato richiede un solo parametro: l'indirizzo del metodo di callback, qualificato dal nome della classe.

Il ParameterizedThreadStart delegato e l'overload del metodo semplificano il Thread.Start(Object) passaggio di dati a una routine thread, ma questa tecnica non è indipendente dai tipi perché qualsiasi oggetto può essere passato a Thread.Start(Object). Un modo più affidabile per passare dati a una routine di thread consiste nell'inserire sia la routine thread che i campi dati in un oggetto di lavoro. Per altre informazioni, vedere Creazione di thread e passaggio di dati all'ora di inizio.

Il ParameterizedThreadStart delegato supporta solo un singolo parametro. È possibile passare più elementi di dati a ParameterizedThreadStart rendendo il parametro uno dei seguenti:

Matrice .
Tipo di raccolta, se tutti gli elementi di dati sono dello stesso tipo.
Tipo di tupla, ad esempio Tuple<T1,T2> o Tuple<T1,T2,T3,T4>.

Metodi di estensione

GetMethodInfo(Delegate)

Ottiene un oggetto che rappresenta il metodo rappresentato dal delegato specificato.

Si applica a

Prodotto	Versioni
.NET	Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7
.NET Framework	2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8
.NET Standard	2.0, 2.1

Condividi tramite

ParameterizedThreadStart Delegato

Definizione

Parametri

Esempio

Commenti

Metodi di estensione

Si applica a

Vedi anche

Risorse aggiuntive