ParameterizedThreadStart Délégué

Référence

Définition

Espace de noms:: System.Threading

Assembly:: System.Threading.Thread.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

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

Paramètres

obj: Object

Objet qui contient les données de la procédure thread.

Attributs: ComVisibleAttribute

Exemples

L’exemple de code suivant utilise un délégué pour exécuter une ParameterizedThreadStart méthode statique et une méthode d’instance. Le premier ParameterizedThreadStart délégué est représenté par la méthode statique DoWork et le second est représenté par la méthode d’instance DoMoreWork . Les deux méthodes correspondent à la ParameterizedThreadStart signature déléguée ; autrement dit, elles ont un seul paramètre de type Object et ne retournent pas de valeur.

Notes

Les compilateurs Visual Basic et C# déduitnt le ParameterizedThreadStart délégué des signatures des DoWork méthodes et DoMoreWork appellent le constructeur correct. Par conséquent, il n’existe aucun appel de constructeur explicite dans le 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

Lorsqu’un thread managé est créé, la méthode qui s’exécute sur le thread est représentée par :

Délégué ThreadStart passé au Thread.Thread(ThreadStart) constructeur. Toute méthode qui n’a aucun paramètre et qui retourne void en C# ou est une Sub procédure dans Visual Basic peut représenter le délégué.
Délégué ParameterizedThreadStart passé au Thread.Thread(ParameterizedThreadStart) constructeur. Toute méthode qui a un seul paramètre de type Object et qui retourne void en C# ou est une sous-procédure dans Visual Basic peut représenter le délégué.

Le thread ne commence pas à s’exécuter tant que la Thread.Start méthode n’est pas appelée. Le ThreadStart ou ParameterizedThreadStart le délégué 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é. Dans le cas du ParameterizedThreadStart délégué, l’objet passé à la Start(Object) méthode est passé au délégué.

Notes

Visual Basic et les utilisateurs C# peuvent omettre le constructeur ou ParameterizedThreadStart le délégué lors de la ThreadStart création d’un thread. Dans Visual Basic, utilisez l’opérateur AddressOf lors du passage de votre méthode au Thread constructeur; par exemple. Dim t As New Thread(AddressOf ThreadProc) En C#, spécifiez simplement le nom de la procédure thread. Le compilateur sélectionne le constructeur délégué approprié.

Notes

Lorsque vous créez un délégué pour une ParameterizedThreadStart méthode d’instance en C++, le premier paramètre du constructeur est la variable d’instance. Pour une méthode statique, le premier paramètre du constructeur est zéro. Pour une méthode statique, le constructeur délégué ne nécessite qu’un seul paramètre : l’adresse de la méthode de rappel, qualifiée par le nom de la classe.

Le ParameterizedThreadStart délégué et la surcharge de méthode facilitent la Thread.Start(Object) transmission de données à une procédure thread, mais cette technique n’est pas sécurisée, car tout objet peut être passé à Thread.Start(Object). Une méthode plus robuste pour transmettre des données à une procédure thread consiste à placer à la fois la procédure thread et les champs de données dans un objet worker. Pour plus d’informations, consultez Création de threads et transmission de données au moment du début.

Le ParameterizedThreadStart délégué ne prend en charge qu’un seul paramètre. Vous pouvez transmettre plusieurs éléments de données à ce ParameterizedThreadStart paramètre l’un des éléments suivants :

Tableau.
Type de collection, si tous les éléments de données sont du même type.
Type tuple, tel que Tuple<T1,T2> ou Tuple<T1,T2,T3,T4>.

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é.

S’applique à

Partager via

ParameterizedThreadStart Délégué

Définition

Paramètres

Exemples

Remarques

Méthodes d’extension

S’applique à

Voir aussi

Ressources supplémentaires