ParameterizedThreadStart Delegato

  • Riferimento

Definizione

Spazio dei nomi:
System.Threading
Assembly:
System.Threading.Thread.dll
Assembly:
mscorlib.dll
Assembly:
netstandard.dll

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:

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:

Metodi di estensione

GetMethodInfo(Delegate)

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

Si applica a

Vedi anche