ParameterizedThreadStart Délégué

Définition

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

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.

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

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

S’applique à

Voir aussi

• ThreadStart
• Thread
• Start
• AppDomain
• Création de threads