Comparteix a través de

ParameterizedThreadStart Delegado

  • Referencia

Definición

Espacio de nombres:
System.Threading
Ensamblado:
System.Threading.Thread.dll
Ensamblado:
mscorlib.dll
Ensamblado:
netstandard.dll

Representa el método que se ejecuta en 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)

Parámetros

obj
Object

Objeto que contiene datos para el procedimiento de subproceso.

Atributos
ComVisibleAttribute

Ejemplos

En el ejemplo de código siguiente se usa un ParameterizedThreadStart delegado para ejecutar un método estático y un método de instancia. El primer ParameterizedThreadStart delegado se representa mediante el método estático DoWork y el segundo se representa mediante el método de instancia DoMoreWork . Ambos métodos coinciden con la ParameterizedThreadStart firma del delegado; es decir, tienen un único parámetro de tipo Object y no devuelven un valor.

Nota

Los compiladores de Visual Basic y C# deducen el ParameterizedThreadStart delegado de las firmas de los DoWork métodos y DoMoreWork y llaman al constructor correcto. Por lo tanto, no hay ninguna llamada explícita al constructor en el código.

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

Comentarios

Cuando se crea un subproceso administrado, el método que se ejecuta en el subproceso se representa mediante:

El subproceso no comienza a ejecutarse hasta que se llama al Thread.Start método . El ThreadStart delegado o ParameterizedThreadStart se invoca en el subproceso y la ejecución comienza en la primera línea del método representado por el delegado. En el caso del ParameterizedThreadStart delegado, el objeto que se pasa al Start(Object) método se pasa al delegado.

Nota

Visual Basic y los usuarios de C# pueden omitir el ThreadStart constructor o ParameterizedThreadStart delegado al crear un subproceso. En Visual Basic, use el operador al pasar el AddressOf Thread método al constructor; por ejemplo, Dim t As New Thread(AddressOf ThreadProc). En C#, simplemente especifique el nombre del procedimiento de subproceso. El compilador selecciona el constructor delegado correcto.

Nota

Cuando se crea un delegado para un ParameterizedThreadStart método de instancia en C++, el primer parámetro del constructor es la variable de instancia. Para un método estático, el primer parámetro del constructor es cero. Para un método estático, el constructor delegado solo requiere un parámetro: la dirección del método de devolución de llamada, calificada por el nombre de clase.

El ParameterizedThreadStart delegado y la sobrecarga del Thread.Start(Object) método facilitan el paso de datos a un procedimiento de subproceso, pero esta técnica no es segura de tipos porque cualquier objeto se puede pasar a Thread.Start(Object). Una manera más sólida de pasar datos a un procedimiento de subproceso es colocar tanto el procedimiento de subproceso como los campos de datos en un objeto de trabajo. Para obtener más información, vea Crear subprocesos y pasar datos a la hora de inicio.

El ParameterizedThreadStart delegado solo admite un único parámetro. Puede pasar varios elementos de datos a ParameterizedThreadStart haciendo que ese parámetro sea uno de los siguientes:

Métodos de extensión

GetMethodInfo(Delegate)

Obtiene un objeto que representa el método representado por el delegado especificado.

Se aplica a

Consulte también