ParameterizedThreadStart Delegát

Definice

Obor názvů:

System.Threading

Sestavení:

System.Threading.Thread.dll

Sestavení:

mscorlib.dll

Sestavení:

netstandard.dll

Představuje metodu, která se spouští na .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)

Parametry

obj

Object

Objekt, který obsahuje data pro proceduru vlákna.

Atributy

ComVisibleAttribute

Příklady

Následující příklad kódu používá ParameterizedThreadStart delegáta ke spuštění statické metody a metody instance. První ParameterizedThreadStart delegát je reprezentován statickou DoWork metodou a druhá je reprezentována metodou instance DoMoreWork . Obě metody odpovídají podpisu delegáta ParameterizedThreadStart . To znamená, že mají jeden parametr typu Object a nevrací hodnotu.

Poznámka

Kompilátory Visual Basic a C# odvozují ParameterizedThreadStart delegáta z podpisů DoWork a metod a DoMoreWork volají správný konstruktor. Proto v kódu neexistuje žádné explicitní volání konstruktoru.

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ě, reprezentována:

• Delegát ThreadStart , který je předán konstruktoru Thread.Thread(ThreadStart) . Jakákoli metoda, která neobsahuje žádné parametry a která se vrátí void v jazyce C# nebo je procedurou Sub v Visual Basic může představovat delegáta.

• Delegát ParameterizedThreadStart , který je předán konstruktoru Thread.Thread(ParameterizedThreadStart) . Jakákoli metoda, která má jeden parametr typu Object a která vrací void v jazyce C# nebo je sub procedura v Visual Basic může představovat delegáta.

Vlákno nezačne spouštět, dokud Thread.Start není volána metoda. V ThreadStart vlákně se vyvolá nebo ParameterizedThreadStart deleguje a spuštění začíná na prvním řádku metody reprezentované delegátem. V případě delegáta ParameterizedThreadStart se objekt předá Start(Object) metodě delegátu.

Poznámka

Visual Basic a uživatelé jazyka C# mohou při vytváření vlákna vynechat ThreadStart konstruktor nebo ParameterizedThreadStart delegovat. V Visual Basic použijte AddressOf operátor při předávání metody konstruktoruThread, Dim t As New Thread(AddressOf ThreadProc)například . V jazyce C# jednoduše zadejte název procedury vlákna. Kompilátor vybere správný konstruktor delegáta.

Poznámka

Když vytvoříte ParameterizedThreadStart delegáta pro metodu instance v jazyce C++, první parametr konstruktoru je proměnná instance. Pro statickou metodu je první parametr konstruktoru nula. Pro statickou metodu konstruktor delegáta vyžaduje pouze jeden parametr: adresu metody zpětného volání kvalifikovanou názvem třídy.

Delegování ParameterizedThreadStart a Thread.Start(Object) přetížení metody usnadňuje předávání dat do procedury vlákna, ale tato technika není typ bezpečný, protože jakýkoli objekt lze předat Thread.Start(Object). Robustnější způsob, jak předat data do procedury vlákna, je umístit proceduru vlákna i datová pole do pracovního objektu. Další informace najdete v tématu Vytváření vláken a předávání dat při spuštění.

Delegát ParameterizedThreadStart podporuje pouze jeden parametr. Do tohoto parametru ParameterizedThreadStart můžete předat více datových položek tak, že tento parametr provedete jedním z následujících způsobů:

• Pole.

• Typ kolekce, pokud jsou všechny datové položky stejného typu.

• Typ řazené kolekce členů, například Tuple<T1,T2> nebo Tuple<T1,T2,T3,T4>.

Metody rozšíření

GetMethodInfo(Delegate)

Získá objekt, který představuje metodu reprezentovanou zadaným delegátem.

Viz také

• ThreadStart
• Thread
• Start
• AppDomain
• Vytváření vláken