ParameterizedThreadStart ParameterizedThreadStart ParameterizedThreadStart ParameterizedThreadStart Delegate

Definición

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

Parámetros

obj
Object Object Object Object

Objeto que contiene datos para el procedimiento de subproceso.An object that contains data for the thread procedure.

Herencia
ParameterizedThreadStartParameterizedThreadStartParameterizedThreadStartParameterizedThreadStart
Atributos

Ejemplos

En el ejemplo de código siguiente ParameterizedThreadStart se usa un delegado para ejecutar un método estático y un método de instancia.The following code example uses a ParameterizedThreadStart delegate to execute a static method and an instance method. El primer ParameterizedThreadStart delegado se representa mediante el método DoWork estático y el segundo se representa mediante el método DoMoreWork de instancia.The first ParameterizedThreadStart delegate is represented by the static DoWork method and the second is represented by the instance DoMoreWork method. Ambos métodos coinciden ParameterizedThreadStart con la firma del delegado, es decir, tienen un único parámetro Object de tipo y no devuelven un valor.Both methods match the ParameterizedThreadStart delegate signature; that is, they have a single parameter of type Object and don't return a value.

Nota

El Visual Basic y C# los compiladores deducen el ParameterizedThreadStart delegado a partir de las firmas de los DoWork métodos y DoMoreWork y llaman al constructor correcto.The Visual Basic and C# compilers infer the ParameterizedThreadStart delegate from the signatures of the DoWork and DoMoreWork methods, and call the correct constructor. Por lo tanto, no hay ninguna llamada de constructor explícita en el código.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.'

Comentarios

Cuando se crea un subproceso administrado, el método que se ejecuta en el subproceso se representa mediante:When a managed thread is created, the method that executes on the thread is represented by:

El subproceso no empieza a ejecutarse hasta Thread.Start que se llama al método.The thread does not begin executing until the Thread.Start method is called. El ThreadStart delegado ParameterizedThreadStart o se invoca en el subproceso y la ejecución comienza en la primera línea del método representado por el delegado.The ThreadStart or ParameterizedThreadStart delegate is invoked on the thread, and execution begins at the first line of the method represented by the delegate. En el caso del ParameterizedThreadStart delegado, el objeto que se pasa Start(Object) al método se pasa al delegado.In the case of the ParameterizedThreadStart delegate, the object that is passed to the Start(Object) method is passed to the delegate.

Nota

Visual Basic y C# los usuarios pueden omitir ParameterizedThreadStart el ThreadStart constructor de delegado o al crear un subproceso.Visual Basic and C# users can omit the ThreadStart or ParameterizedThreadStart delegate constructor when creating a thread. En Visual Basic, use el AddressOf operador al pasar el método Thread al constructor; por ejemplo, Dim t As New Thread(AddressOf ThreadProc).In Visual Basic, use the AddressOf operator when passing your method to the Thread constructor; for example, Dim t As New Thread(AddressOf ThreadProc). En C#, basta con especificar el nombre del procedimiento de subproceso.In C#, simply specify the name of the thread procedure. El compilador selecciona el constructor de delegado correcto.The compiler selects the correct delegate constructor.

Nota

Cuando se crea un ParameterizedThreadStart delegado para un método de instancia C++en, el primer parámetro del constructor es la variable de instancia.When you create a ParameterizedThreadStart delegate for an instance method in C++, the first parameter of the constructor is the instance variable. Para un método estático, el primer parámetro del constructor es cero.For a static method, the first parameter of the constructor is zero. Para un método estático, el constructor de delegado solo requiere un parámetro: la dirección del método de devolución de llamada, calificado por el nombre de clase.For a static method, the delegate constructor requires only one parameter: the address of the callback method, qualified by the class name.

El ParameterizedThreadStart delegado y la Thread.Start(Object) sobrecarga del método facilitan el paso de los datos a un procedimiento de subproceso, pero esta técnica no tiene seguridad de tipos porque se Thread.Start(Object)puede pasar cualquier objeto a.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). Una forma más sólida de pasar los datos a un procedimiento de subproceso consiste en colocar el procedimiento de subproceso y los campos de datos en un objeto de trabajo.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. Para obtener más información, vea crear subprocesos y pasar datos a la hora de inicio.For more information, see Creating Threads and Passing Data at Start Time.

El ParameterizedThreadStart delegado solo admite un parámetro.The ParameterizedThreadStart delegate supports only a single parameter. Puede pasar varios elementos de datos a ParameterizedThreadStart haciendo que ese parámetro sea uno de los siguientes:You can pass multiple data items to the ParameterizedThreadStart by making that parameter one of the following:

Métodos de extensión

GetMethodInfo(Delegate) GetMethodInfo(Delegate) GetMethodInfo(Delegate) GetMethodInfo(Delegate)

Obtiene un objeto que representa el método representado por el delegado especificado.Gets an object that represents the method represented by the specified delegate.

Se aplica a

Consulte también: