' This example shows how to create an object containing task
' information, and pass that object to a task queued for
' execution by the thread pool.
Imports System
Imports System.Threading
' TaskInfo holds state information for a task that will be
' executed by a ThreadPool thread.
Public Class TaskInfo
    ' State information for the task.  These members
    ' can be implemented as read-only properties, read/write
    ' properties with validation, and so on, as required.
    Public Boilerplate As String
    Public Value As Integer

    ' Public constructor provides an easy way to supply all
    ' the information needed for the task.
    Public Sub New(text As String, number As Integer)
        Boilerplate = text
        Value = number
    End Sub
End Class

Public Class Example

    <MTAThread> _
    Public Shared Sub Main()
        ' Create an object containing the information needed
        ' for the task.
        Dim ti As New TaskInfo("This report displays the number {0}.", 42)

        ' Queue the task and data.
        If ThreadPool.QueueUserWorkItem( _
            New WaitCallback(AddressOf ThreadProc), ti) Then

            Console.WriteLine("Main thread does some work, then sleeps.")

            ' If you comment out the Sleep, the main thread exits before
            ' the ThreadPool task has a chance to run.  ThreadPool uses 
            ' background threads, which do not keep the application 
            ' running.  (This is a simple example of a race condition.)
            Thread.Sleep(1000)

            Console.WriteLine("Main thread exits.")
        Else
            Console.WriteLine("Unable to queue ThreadPool request.")
        End If
    End Sub

    ' The thread procedure performs the independent task, in this case
    ' formatting and printing a very simple report.
    '
    Shared Sub ThreadProc(stateInfo As Object)
        Dim ti As TaskInfo = CType(stateInfo, TaskInfo)
        Console.WriteLine(ti.Boilerplate, ti.Value)
    End Sub
End Class

// This example shows how to create an object containing task
// information, and pass that object to a task queued for
// execution by the thread pool.
using System;
using System.Threading;

// TaskInfo holds state information for a task that will be
// executed by a ThreadPool thread.
public class TaskInfo {
    // State information for the task.  These members
    // can be implemented as read-only properties, read/write
    // properties with validation, and so on, as required.
    public string Boilerplate;
    public int Value;

    // Public constructor provides an easy way to supply all
    // the information needed for the task.
    public TaskInfo(string text, int number) {
        Boilerplate = text;
        Value = number;
    }
}

public class Example {
    public static void Main() {
        // Create an object containing the information needed
        // for the task.
        TaskInfo ti = new TaskInfo("This report displays the number {0}.", 42);

        // Queue the task and data.
        if (ThreadPool.QueueUserWorkItem(new WaitCallback(ThreadProc), ti)) {    
            Console.WriteLine("Main thread does some work, then sleeps.");

            // If you comment out the Sleep, the main thread exits before
            // the ThreadPool task has a chance to run.  ThreadPool uses 
            // background threads, which do not keep the application 
            // running.  (This is a simple example of a race condition.)
            Thread.Sleep(1000);

            Console.WriteLine("Main thread exits.");
        }
        else {
            Console.WriteLine("Unable to queue ThreadPool request."); 
        }
    }

    // The thread procedure performs the independent task, in this case
    // formatting and printing a very simple report.
    //
    static void ThreadProc(Object stateInfo) {
        TaskInfo ti = (TaskInfo) stateInfo;
        Console.WriteLine(ti.Boilerplate, ti.Value); 
    }
}

// This example shows how to create an Object* containing task
// information, and pass that Object* to a task queued for
// execution by the thread pool.
using namespace System;
using namespace System::Threading;

// TaskInfo holds state information for a task that will be
// executed by a ThreadPool thread.
public ref class TaskInfo
{
public:

   // State information for the task.  These members
   // can be implemented as read-only properties, read/write
   // properties with validation, and so on, as required.
   String^ Boilerplate;
   int Value;

   // Public constructor provides an easy way to supply all
   // the information needed for the task.
   TaskInfo( String^ text, int number )
   {
      Boilerplate = text;
      Value = number;
   }

};

public ref struct Example
{
public:

   // The thread procedure performs the independent task, in this case
   // formatting and printing a very simple report.
   //
   static void ThreadProc( Object^ stateInfo )
   {
      TaskInfo^ ti = dynamic_cast<TaskInfo^>(stateInfo);
      Console::WriteLine( ti->Boilerplate, ti->Value );
   }

};

int main()
{

   // Create an object containing the information needed
   // for the task.
   TaskInfo^ ti = gcnew TaskInfo( "This report displays the number {0}.",42 );

   // Queue the task and data.
   if ( ThreadPool::QueueUserWorkItem( gcnew WaitCallback( Example::ThreadProc ), ti ) )
   {
      Console::WriteLine( "Main thread does some work, then sleeps." );

      // If you comment out the Sleep, the main thread exits before
      // the ThreadPool task has a chance to run.  ThreadPool uses 
      // background threads, which do not keep the application 
      // running.  (This is a simple example of a race condition.)
      Thread::Sleep( 1000 );
      Console::WriteLine( "Main thread exits." );
   }
   else
   {
      Console::WriteLine( "Unable to queue ThreadPool request." );
   }

   return 0;
}

// This example shows how to create an object containing task
// information, and pass that object to a task queued for
// execution by the thread pool.
import System.*;
import System.Threading.*;
import System.Threading.Thread;

// TaskInfo holds state information for a task that will be
// executed by a ThreadPool thread.
public class TaskInfo
{
    // State information for the task.  These members
    // can be implemented as read-only properties, read/write
    // properties with validation, and so on, as required.
    public String boilerplate;
    public int value;

    // Public constructor provides an easy way to supply all
    // the information needed for the task.
    public TaskInfo(String text, int number)
    {
        boilerplate = text;
        value = number;
    } //TaskInfo
} //TaskInfo

public class Example
{
    public static void main(String[] args)
    {
        // Create an object containing the information needed
        // for the task.
        TaskInfo ti = new TaskInfo("This report displays the number {0}.", 42);

        // Queue the task and data.
        if (ThreadPool.QueueUserWorkItem(new WaitCallback(ThreadProc), ti)) {
            Console.WriteLine("Main thread does some work, then sleeps.");

            // If you comment out the Sleep, the main thread exits before
            // the ThreadPool task has a chance to run.  ThreadPool uses 
            // background threads, which do not keep the application 
            // running.  (This is a simple example of a race condition.)
            Thread.Sleep(1000);
            Console.WriteLine("Main thread exits.");
        }
        else {
            Console.WriteLine("Unable to queue ThreadPool request.");
        }
    } //main

    // The thread procedure performs the independent task, in this case
    // formatting and printing a very simple report.
    //
    static void ThreadProc(Object stateInfo)
    {
        TaskInfo ti = ((TaskInfo)(stateInfo));

        Console.WriteLine(ti.boilerplate, String.valueOf(ti.value));
    } //ThreadProc
} //Example