ParameterizedThreadStart ParameterizedThreadStart ParameterizedThreadStart ParameterizedThreadStart Delegate

Definizione

Rappresenta il metodo eseguito in un oggetto Thread.Represents the method that executes on a Thread.

public delegate void ParameterizedThreadStart(System::Object ^ obj);
[System.Runtime.InteropServices.ComVisible(false)]
public delegate void ParameterizedThreadStart(object obj);
type ParameterizedThreadStart = delegate of obj -> unit
Public Delegate Sub ParameterizedThreadStart(obj As Object)

Parametri

obj
Object Object Object Object

Oggetto che contiene i dati per la routine del thread.An object that contains data for the thread procedure.

Ereditarietà
ParameterizedThreadStartParameterizedThreadStartParameterizedThreadStartParameterizedThreadStart
Attributi

Esempi

Il codice seguente viene illustrato come utilizzare un ParameterizedThreadStart delegato per eseguire un metodo statico e un metodo di istanza.The following code example uses a ParameterizedThreadStart delegate to execute a static method and an instance method. Il primo ParameterizedThreadStart delegato è rappresentato da statica DoWork metodo e il secondo è rappresentato dall'istanza DoMoreWork (metodo).The first ParameterizedThreadStart delegate is represented by the static DoWork method and the second is represented by the instance DoMoreWork method. Entrambi i metodi di corrispondono il ParameterizedThreadStart firma del delegato; vale a dire, hanno un solo parametro di tipo Object e non restituisce alcun valore.Both methods match the ParameterizedThreadStart delegate signature; that is, they have a single parameter of type Object and don't return a value.

Nota

I compilatori Visual Basic e c# è in grado di dedurre il ParameterizedThreadStart delegare dalle firme del DoWork e DoMoreWork metodi e chiamare il costruttore corretto.The Visual Basic and C# compilers infer the ParameterizedThreadStart delegate from the signatures of the DoWork and DoMoreWork methods, and call the correct constructor. Pertanto, non è disponibile nessuna chiamata esplicita al costruttore nel codice.Thus, there is no explicit constructor call in the code.

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 che viene eseguita sul thread è rappresentato da:When a managed thread is created, the method that executes on the thread is represented by:

Il thread non viene avviata l'esecuzione finché la Thread.Start viene chiamato il metodo.The thread does not begin executing until the Thread.Start method is called. Il ThreadStart o ParameterizedThreadStart delegato viene richiamato sul thread e l'esecuzione in cui inizia la prima riga del metodo rappresentato dal delegato.The ThreadStart or ParameterizedThreadStart delegate is invoked on the thread, and execution begins at the first line of the method represented by the delegate. Nel caso del ParameterizedThreadStart delegato, l'oggetto che viene passato per il Start(Object) viene passato al delegato.In the case of the ParameterizedThreadStart delegate, the object that is passed to the Start(Object) method is passed to the delegate.

Nota

Gli utenti di Visual Basic e c# è possono omettere il ThreadStart o ParameterizedThreadStart costruttore di delegato durante la creazione di un thread.Visual Basic and C# users can omit the ThreadStart or ParameterizedThreadStart delegate constructor when creating a thread. In Visual Basic, usare il AddressOf operatore quando si passa il metodo esegua la Thread costruttore, ad esempio Dim t As New Thread(AddressOf ThreadProc).In Visual Basic, use the AddressOf operator when passing your method to the Thread constructor; for example, Dim t As New Thread(AddressOf ThreadProc). In c#, è sufficiente specificare il nome della routine del thread.In C#, simply specify the name of the thread procedure. Il compilatore seleziona il costruttore di delegato corretto.The compiler selects the correct delegate constructor.

Nota

Quando si crea un ParameterizedThreadStart delegato per un metodo di istanza in C++, il primo parametro del costruttore è la variabile di istanza.When you create a ParameterizedThreadStart delegate for an instance method in C++, the first parameter of the constructor is the instance variable. Per un metodo statico, il primo parametro del costruttore è zero.For a static method, the first parameter of the constructor is zero. Per un metodo statico, il costruttore di delegato richiede un solo parametro: l'indirizzo del metodo di callback, qualificato dal nome della classe.For a static method, the delegate constructor requires only one parameter: the address of the callback method, qualified by the class name.

Il ParameterizedThreadStart delegato e il Thread.Start(Object) overload del metodo rendono più semplice passare dati a una routine del thread, ma questa tecnica non è indipendente dai tipi perché qualsiasi oggetto può essere passato a Thread.Start(Object).The ParameterizedThreadStart delegate and the Thread.Start(Object) method overload make it easy to pass data to a thread procedure, but this technique is not type safe because any object can be passed to Thread.Start(Object). Un modo più efficiente per passare dati a una routine del thread è inserire sia la routine del thread e i campi dati in un oggetto di lavoro.A more robust way to pass data to a thread procedure is to put both the thread procedure and the data fields into a worker object. Per altre informazioni, vedere creazione di thread e passaggio di dati in fase di avvio.For more information, see Creating Threads and Passing Data at Start Time.

Il ParameterizedThreadStart delegato supporta solo un singolo parametro.The ParameterizedThreadStart delegate supports only a single parameter. È possibile passare più elementi di dati per il ParameterizedThreadStart apportando tale parametro uno dei seguenti:You can pass multiple data items to the ParameterizedThreadStart by making that parameter one of the following:

Extension Methods

GetMethodInfo(Delegate) GetMethodInfo(Delegate) GetMethodInfo(Delegate) GetMethodInfo(Delegate)

Ottiene un oggetto che rappresenta il metodo rappresentato dal delegato specificato.Gets an object that represents the method represented by the specified delegate.

Si applica a

Vedi anche