ParameterizedThreadStart ParameterizedThreadStart ParameterizedThreadStart ParameterizedThreadStart Delegate

Definition

Stellt die Methode dar, die in einem Thread ausgeführt wird.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)

Parameter

obj
Object Object Object Object

Ein Objekt, das Daten für die Threadprozedur enthält.An object that contains data for the thread procedure.

Vererbung
ParameterizedThreadStartParameterizedThreadStartParameterizedThreadStartParameterizedThreadStart
Attribute

Beispiele

Im folgenden Codebeispiel wird ein ParameterizedThreadStart -Delegat verwendet, um eine statische Methode und eine Instanzmethode auszuführen.The following code example uses a ParameterizedThreadStart delegate to execute a static method and an instance method. Der erste ParameterizedThreadStart Delegat wird durch die statische DoWork -Methode dargestellt, und die zweite wird durch DoMoreWork die-Instanzmethode dargestellt.The first ParameterizedThreadStart delegate is represented by the static DoWork method and the second is represented by the instance DoMoreWork method. Beide Methoden stimmen mit ParameterizedThreadStart der Signatur des Delegaten, d. h., Sie verfügen Object über einen einzelnen Parameter vom Typ und geben keinen Wert zurück.Both methods match the ParameterizedThreadStart delegate signature; that is, they have a single parameter of type Object and don't return a value.

Hinweis

Die Visual Basic und C# Compiler leiten den ParameterizedThreadStart Delegaten aus DoWork den Signaturen der-Methode und DoMoreWork der-Methode ab und wenden den korrekten Konstruktor an.The Visual Basic and C# compilers infer the ParameterizedThreadStart delegate from the signatures of the DoWork and DoMoreWork methods, and call the correct constructor. Folglich gibt es keinen expliziten Konstruktoraufrufe im Code.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.'

Hinweise

Wenn ein verwalteter Thread erstellt wird, wird die-Methode, die auf dem Thread ausgeführt wird, durch Folgendes dargestellt:When a managed thread is created, the method that executes on the thread is represented by:

Der Thread beginnt erst mit der Ausführung, Thread.Start wenn die-Methode aufgerufen wird.The thread does not begin executing until the Thread.Start method is called. Der ThreadStart - ParameterizedThreadStart oder der-Delegat wird für den Thread aufgerufen, und die Ausführung beginnt in der ersten Zeile der Methode, die durch den-Delegaten dargestellt wird.The ThreadStart or ParameterizedThreadStart delegate is invoked on the thread, and execution begins at the first line of the method represented by the delegate. Im Fall des ParameterizedThreadStart -Delegaten wird das-Objekt, das an die Start(Object) -Methode übermittelt wird, an den-Delegaten übermittelt.In the case of the ParameterizedThreadStart delegate, the object that is passed to the Start(Object) method is passed to the delegate.

Hinweis

Visual Basic und C# Benutzer können den ThreadStart -oder ParameterizedThreadStart -Delegatkonstruktor weglassen, wenn ein Thread erstellt wird.Visual Basic and C# users can omit the ThreadStart or ParameterizedThreadStart delegate constructor when creating a thread. Verwenden Sie in Visual Basic den AddressOf -Operator, wenn Sie die Methode Thread an den- Dim t As New Thread(AddressOf ThreadProc)Konstruktor übergeben, z. b.In Visual Basic, use the AddressOf operator when passing your method to the Thread constructor; for example, Dim t As New Thread(AddressOf ThreadProc). Geben C#Sie in einfach den Namen der Thread Prozedur an.In C#, simply specify the name of the thread procedure. Der Compiler wählt den korrekten Delegatkonstruktor aus.The compiler selects the correct delegate constructor.

Hinweis

Wenn Sie in C++einen ParameterizedThreadStart Delegaten für eine Instanzmethode erstellen, ist der erste Parameter des Konstruktors die Instanzvariable.When you create a ParameterizedThreadStart delegate for an instance method in C++, the first parameter of the constructor is the instance variable. Bei einer statischen Methode ist der erste Parameter des Konstruktors 0 (null).For a static method, the first parameter of the constructor is zero. Für eine statische Methode benötigt der Delegatkonstruktor nur einen Parameter: die Adresse der Rückruf Methode, die durch den Klassennamen qualifiziert ist.For a static method, the delegate constructor requires only one parameter: the address of the callback method, qualified by the class name.

Der ParameterizedThreadStart -Delegat Thread.Start(Object) und die-Methoden Überladung vereinfachen das Übergeben von Daten an eine Thread Prozedur, diese Technik ist jedoch nicht typsicher, da jedes Objekt Thread.Start(Object)an übergeben werden kann.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). Eine stabilere Methode zum Übergeben von Daten an eine Thread Prozedur besteht darin, die Thread Prozedur und die Datenfelder in ein Workerobjekt einzufügen.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. Weitere Informationen finden Sie unter Erstellen von Threads und übergeben von Daten zur Startzeit.For more information, see Creating Threads and Passing Data at Start Time.

Der ParameterizedThreadStart Delegat unterstützt nur einen einzelnen Parameter.The ParameterizedThreadStart delegate supports only a single parameter. Sie können mehrere Datenelemente an den ParameterizedThreadStart übergeben, indem Sie für diesen Parameter einen der folgenden Parameter festlegen:You can pass multiple data items to the ParameterizedThreadStart by making that parameter one of the following:

Erweiterungsmethoden

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

Ruft ein Objekt ab, das die Methode darstellt, die vom angegebenen Delegaten dargestellt wird.Gets an object that represents the method represented by the specified delegate.

Gilt für:

Siehe auch