ParameterizedThreadStart Delegát

Definice

Představuje metodu, která se spouští na Thread.Represents the method that executes on a 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);
type ParameterizedThreadStart = delegate of obj -> unit
Public Delegate Sub ParameterizedThreadStart(obj As Object)

Parametry

obj
Object

Objekt, který obsahuje data pro proceduru vlákna.An object that contains data for the thread procedure.

Dědičnost
ParameterizedThreadStart
Atributy

Příklady

Následující příklad kódu používá delegáta ParameterizedThreadStart ke spuštění statické metody a metody instance.The following code example uses a ParameterizedThreadStart delegate to execute a static method and an instance method. První ParameterizedThreadStart delegát je reprezentován statickou DoWork metodou a druhá je reprezentovaná metodou instance DoMoreWork.The first ParameterizedThreadStart delegate is represented by the static DoWork method and the second is represented by the instance DoMoreWork method. Obě metody odpovídají signaturě delegáta ParameterizedThreadStart; To znamená, že mají jeden parametr typu Object a nevrací hodnotu.Both methods match the ParameterizedThreadStart delegate signature; that is, they have a single parameter of type Object and don't return a value.

Poznámka

Visual Basic a C# kompilátory odvozují ParameterizedThreadStart delegáta z signatury DoWork a DoMoreWorkch metod a volají správný konstruktor.The Visual Basic and C# compilers infer the ParameterizedThreadStart delegate from the signatures of the DoWork and DoMoreWork methods, and call the correct constructor. Proto není v kódu žádné explicitní volání konstruktoru.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.'

Poznámky

Při vytvoření spravovaného vlákna je metoda, která se spouští ve vlákně, reprezentovaná:When a managed thread is created, the method that executes on the thread is represented by:

Vlákno se nezačne spouštět, dokud není volána metoda Thread.Start.The thread does not begin executing until the Thread.Start method is called. Delegát ThreadStart nebo ParameterizedThreadStart je vyvolán ve vlákně a provádění začíná na prvním řádku metody reprezentované delegátem.The ThreadStart or ParameterizedThreadStart delegate is invoked on the thread, and execution begins at the first line of the method represented by the delegate. V případě delegáta ParameterizedThreadStart je objekt, který je předán metodě Start(Object), předán delegátovi.In the case of the ParameterizedThreadStart delegate, the object that is passed to the Start(Object) method is passed to the delegate.

Poznámka

Visual Basic a C# uživatelé mohou při vytváření vlákna vynechat konstruktor Delegate ThreadStart nebo ParameterizedThreadStart.Visual Basic and C# users can omit the ThreadStart or ParameterizedThreadStart delegate constructor when creating a thread. V Visual Basic použijte operátor AddressOf při předávání metody do konstruktoru Thread; například 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). V C#zadejte jednoduše název procedury vlákna.In C#, simply specify the name of the thread procedure. Kompilátor vybere správný konstruktor delegáta.The compiler selects the correct delegate constructor.

Poznámka

Při vytváření delegáta ParameterizedThreadStart pro metodu instance v C++nástroji je prvním parametrem konstruktoru proměnná instance.When you create a ParameterizedThreadStart delegate for an instance method in C++, the first parameter of the constructor is the instance variable. Pro statickou metodu je prvním parametrem konstruktoru nula.For a static method, the first parameter of the constructor is zero. Pro statickou metodu konstruktor Delegate vyžaduje pouze jeden parametr: adresu metody zpětného volání, která je kvalifikována názvem třídy.For a static method, the delegate constructor requires only one parameter: the address of the callback method, qualified by the class name.

Delegování ParameterizedThreadStart a přetížení metody Thread.Start(Object) usnadňuje předávání dat do procedury vlákna, ale tato technika není typově bezpečná, protože libovolný objekt lze předat Thread.Start(Object).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). Robustnější způsob, jak předat data proceduře vlákna, je umístit proceduru vlákna i datová pole do objektu Worker.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. Další informace najdete v tématu vytváření vláken a předávání dat v počátečním čase.For more information, see Creating Threads and Passing Data at Start Time.

Delegát ParameterizedThreadStart podporuje pouze jeden parametr.The ParameterizedThreadStart delegate supports only a single parameter. Do ParameterizedThreadStart můžete předat více datových položek tak, že tento parametr nastavíte jednu z následujících možností:You can pass multiple data items to the ParameterizedThreadStart by making that parameter one of the following:

Metody rozšíření

GetMethodInfo(Delegate)

Získává objekt, který představuje metodu reprezentovanou zadaným delegátem.Gets an object that represents the method represented by the specified delegate.

Platí pro

Viz také