ParameterizedThreadStart Delegar

Definição

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)

Parâmetros

Atributos

ComVisibleAttribute

Exemplos

O exemplo de código a seguir usa um ParameterizedThreadStart delegado para executar um método estático e um método de instância. O primeiro ParameterizedThreadStart delegado é representado pelo método estático DoWork e o segundo é representado pelo método de instância DoMoreWork . Ambos os métodos correspondem à ParameterizedThreadStart assinatura delegada; ou seja, eles têm um único parâmetro de tipo Object e não retornam um valor.

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

Comentários

Quando um thread gerenciado é criado, o método que é executado no thread é representado por:

• Um ThreadStart delegado que é passado para o Thread.Thread(ThreadStart) construtor. Qualquer método que não tenha parâmetros e que retorne void em C# ou seja um Sub procedimento em Visual Basic pode representar o delegado.

• Um ParameterizedThreadStart delegado que é passado para o Thread.Thread(ParameterizedThreadStart) construtor. Qualquer método que tenha um único parâmetro de tipo Object e que retorne nulo em C# ou seja um sub procedimento em Visual Basic pode representar o delegado.

O thread não começa a ser executado até que o Thread.Start método seja chamado. O ThreadStart delegado ou ParameterizedThreadStart o delegado é invocado no thread e a execução começa na primeira linha do método representado pelo delegado. No caso do ParameterizedThreadStart delegado, o objeto que é passado para o Start(Object) método é passado para o delegado.

O ParameterizedThreadStart delegado e a sobrecarga do Thread.Start(Object) método facilitam a passagem de dados para um procedimento de thread, mas essa técnica não é tipada como segura porque qualquer objeto pode ser passado para Thread.Start(Object). Uma maneira mais robusta de passar dados para um procedimento de thread é colocar o procedimento de thread e os campos de dados em um objeto de trabalho. Para obter mais informações, consulte Criando threads e passando dados na hora de início.

O ParameterizedThreadStart delegado dá suporte a apenas um único parâmetro. Você pode passar vários itens de dados para o ParameterizedThreadStart fazendo desse parâmetro um dos seguintes:

• Uma matriz .

• Um tipo de coleção, se todos os itens de dados forem do mesmo tipo.

• Um tipo de tupla, como Tuple<T1,T2> ou Tuple<T1,T2,T3,T4>.

Métodos de Extensão

Aplica-se a

Confira também

• ThreadStart
• Thread
• Start
• AppDomain
• Criando threads