ParameterizedThreadStart Délégué

Définition

Représente la méthode qui s’exécute sur un élément 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)

Paramètres

obj
Object

Objet qui contient les données de la procédure thread.An object that contains data for the thread procedure.

Héritage
ParameterizedThreadStart
Attributs

Exemples

L’exemple de code suivant utilise ParameterizedThreadStart un délégué pour exécuter une méthode statique et une méthode d’instance.The following code example uses a ParameterizedThreadStart delegate to execute a static method and an instance method. Le premier ParameterizedThreadStart délégué est représenté par la méthode DoWork statique et le second est représenté par la méthode DoMoreWork d’instance.The first ParameterizedThreadStart delegate is represented by the static DoWork method and the second is represented by the instance DoMoreWork method. Les deux méthodes correspondent ParameterizedThreadStart à la signature du délégué; autrement dit, elles ont un seul Object paramètre de type et ne retournent pas de valeur.Both methods match the ParameterizedThreadStart delegate signature; that is, they have a single parameter of type Object and don't return a value.

Notes

Les Visual Basic et C# les compilateurs déduisent ParameterizedThreadStart le délégué des signatures des DoWork méthodes et DoMoreWork , et appellent le constructeur correct.The Visual Basic and C# compilers infer the ParameterizedThreadStart delegate from the signatures of the DoWork and DoMoreWork methods, and call the correct constructor. Ainsi, il n’y a pas d’appel de constructeur explicite dans le 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.'

Remarques

Quand un thread managé est créé, la méthode qui s’exécute sur le thread est représentée par:When a managed thread is created, the method that executes on the thread is represented by:

Le thread ne commence pas à s’exécuter tant Thread.Start que la méthode n’est pas appelée.The thread does not begin executing until the Thread.Start method is called. Le ThreadStart délégué ParameterizedThreadStart ou est appelé sur le thread, et l’exécution commence à la première ligne de la méthode représentée par le délégué.The ThreadStart or ParameterizedThreadStart delegate is invoked on the thread, and execution begins at the first line of the method represented by the delegate. Dans le cas du ParameterizedThreadStart délégué, l’objet passé à la Start(Object) méthode est passé au délégué.In the case of the ParameterizedThreadStart delegate, the object that is passed to the Start(Object) method is passed to the delegate.

Notes

Visual Basic et C# les utilisateurs peuvent omettre ThreadStart le ParameterizedThreadStart constructeur délégué ou lors de la création d’un thread.Visual Basic and C# users can omit the ThreadStart or ParameterizedThreadStart delegate constructor when creating a thread. Dans Visual Basic, utilisez l' AddressOf opérateur lors du passage de votre méthode Thread au Dim t As New Thread(AddressOf ThreadProc)constructeur, par exemple.In Visual Basic, use the AddressOf operator when passing your method to the Thread constructor; for example, Dim t As New Thread(AddressOf ThreadProc). Dans C#, spécifiez simplement le nom de la procédure de thread.In C#, simply specify the name of the thread procedure. Le compilateur sélectionne le constructeur délégué approprié.The compiler selects the correct delegate constructor.

Notes

Quand vous créez un ParameterizedThreadStart délégué pour une méthode d’instance C++dans, le premier paramètre du constructeur est la variable d’instance.When you create a ParameterizedThreadStart delegate for an instance method in C++, the first parameter of the constructor is the instance variable. Pour une méthode statique, le premier paramètre du constructeur est égal à zéro.For a static method, the first parameter of the constructor is zero. Pour une méthode statique, le constructeur délégué ne requiert qu’un seul paramètre: l’adresse de la méthode de rappel, qualifiée par le nom de la classe.For a static method, the delegate constructor requires only one parameter: the address of the callback method, qualified by the class name.

Le ParameterizedThreadStart délégué et la Thread.Start(Object) surcharge de méthode facilitent le passage de données à une procédure de thread, mais cette technique n’est pas de type sécurisé, car tout Thread.Start(Object)objet peut être passé à.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 moyen plus robuste de passer des données à une procédure de thread consiste à placer la procédure de thread et les champs de données dans un objet de travail.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. Pour plus d’informations, consultez création de threads et passage de données à l’heure de début.For more information, see Creating Threads and Passing Data at Start Time.

Le ParameterizedThreadStart délégué ne prend en charge qu’un seul paramètre.The ParameterizedThreadStart delegate supports only a single parameter. Vous pouvez passer plusieurs éléments de données à ParameterizedThreadStart la en faisant de ce paramètre l’un des éléments suivants:You can pass multiple data items to the ParameterizedThreadStart by making that parameter one of the following:

Méthodes d’extension

GetMethodInfo(Delegate)

Obtient un objet qui représente la méthode représentée par le délégué spécifié.Gets an object that represents the method represented by the specified delegate.

S’applique à

Voir aussi