ParameterizedThreadStart Delegat

Definition

Namespace:

System.Threading

Assembly:

System.Threading.Thread.dll

Assembly:

mscorlib.dll

Assembly:

netstandard.dll

Stellt die Methode dar, die in einem Thread ausgeführt wird.

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)

Parameter

obj

Object

Ein Objekt, das Daten für die Threadprozedur enthält.

Attribute

ComVisibleAttribute

Beispiele

Im folgenden Codebeispiel wird eine Stellvertretung verwendet, um eine ParameterizedThreadStart statische Methode und eine Instanzmethode auszuführen. Der erste ParameterizedThreadStart Stellvertretung wird durch die statische DoWork Methode dargestellt und der zweite wird durch die Instanzmethode DoMoreWork dargestellt. Beide Methoden entsprechen der ParameterizedThreadStart Stellvertretungssignatur; das heißt, sie verfügen über einen einzelnen Parameter des Typs Object und geben keinen Wert zurück.

Hinweis

Die Visual Basic- und C#-Compiler führen die ParameterizedThreadStart Stellvertretung aus den Signaturen der DoWork DoMoreWork und Methoden aus, und rufen Sie den richtigen Konstruktor auf. Daher gibt es keinen expliziten Konstruktoraufruf im 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 im Thread ausgeführt wird, durch folgendes dargestellt:

• Ein ThreadStart Stellvertretung, der an den Thread.Thread(ThreadStart) Konstruktor übergeben wird. Jede Methode, die void keine Parameter enthält und in C# zurückgibt oder eine Sub Prozedur in Visual Basic ist, kann die Stellvertretung darstellen.

• Ein ParameterizedThreadStart Stellvertretung, der an den Thread.Thread(ParameterizedThreadStart) Konstruktor übergeben wird. Jede Methode, die einen einzelnen Parameter des Typs Object aufweist und in C# leer gibt oder eine Subprozedur in Visual Basic ist, kann die Stellvertretung darstellen.

Der Thread beginnt erst, wenn die Thread.Start Methode aufgerufen wird. ParameterizedThreadStart Der ThreadStart oder die Stellvertretung wird im Thread aufgerufen, und die Ausführung beginnt an der ersten Zeile der Methode, die durch den Stellvertretung dargestellt wird. Im Fall der ParameterizedThreadStart Stellvertretung wird das objekt, das an die Methode übergeben wird, an den Start(Object) Stellvertretung übergeben.

Hinweis

Visual Basic und C#-Benutzer können den ThreadStart Konstruktor beim Erstellen eines Threads auslassen oder ParameterizedThreadStart delegieren. Verwenden Sie in Visual Basic den Operator, wenn Sie die AddressOf Methode an den Thread Konstruktor übergeben, zDim t As New Thread(AddressOf ThreadProc). B. . Geben Sie in C#einfach den Namen der Threadprozedur an. Der Compiler wählt den richtigen Stellvertretungskonstruktor aus.

Hinweis

Wenn Sie eine Stellvertretung für eine ParameterizedThreadStart Instanzmethode in C++erstellen, ist der erste Parameter des Konstruktors die Instanzvariable. Bei einer statischen Methode ist der erste Parameter des Konstruktors Null. Für eine statische Methode erfordert der Stellvertretungskonstruktor nur einen Parameter: die Adresse der Rückrufmethode, die durch den Klassennamen qualifiziert ist.

Die Stellvertretung und die ParameterizedThreadStart Thread.Start(Object) Methodenüberladung ermöglichen es, Daten an eine Threadprozedur zu übergeben, aber diese Technik ist nicht typsicher, da jedes Objekt an Thread.Start(Object)übergeben werden kann. Eine robustere Möglichkeit zum Übergeben von Daten an eine Threadprozedur besteht darin, sowohl die Threadprozedur als auch die Datenfelder in ein Arbeitsobjekt einzufügen. Weitere Informationen finden Sie unter Erstellen von Threads und Übergeben von Daten zu Startzeit.

Der ParameterizedThreadStart Stellvertretung unterstützt nur einen einzelnen Parameter. Sie können mehrere Datenelemente an den ParameterizedThreadStart folgenden Parameter übergeben:

• Ein -Array.

• Ein Auflistungstyp, wenn alle Datenelemente vom gleichen Typ sind.

• Ein Tupletyp, z Tuple<T1,T2> . B. oder Tuple<T1,T2,T3,T4>.

Erweiterungsmethoden

GetMethodInfo(Delegate)

Ruft ein Objekt ab, das die Methode darstellt, die vom angegebenen Delegaten dargestellt wird.

Siehe auch

• ThreadStart
• Thread
• Start
• AppDomain
• Erstellen von Threads