The following example demonstrates how to use the ThreadPool class to execute a method named DisplayMessage. The example passes DisplayMessage to the thread pool twice, first with no arguments and then with a MessageInfo object, which allows you to control which message the new thread will display:

using System;
using System.Threading;

namespace Apress.VisualCSharpRecipes.Chapter04
{
    class Recipe04_01
    {

        // A private class used to pass data to the DisplayMessage method when it is
        // executed using the thread pool.
        private class MessageInfo
        {
            private int iterations;
            private string message;

            // A constructor that takes configuration settings for the thread.
            public MessageInfo(int iterations, string message)
            {
                this.iterations = iterations;
                this.message = message;
            }

            // Properties to retrieve configuration settings.
            public int Iterations { get { return iterations; } }
            public string Message { get { return message; } }
        }

        // A method that conforms to the System.Threading.WaitCallback delegate
        // signature. Displays a message to the console.
        public static void DisplayMessage(object state)
        {
            // Safely cast the state argument to a MessageInfo object.
            MessageInfo config = state as MessageInfo;

            // If the config argument is null, no arguments were passed to
            // the ThreadPool.QueueUserWorkItem method; use default values.
            if (config == null)
            {
                // Display a fixed message to the console three times.
                for (int count = 0; count < 3; count++)
                {
                    Console.WriteLine("A thread pool example.");

                    // Sleep for the purpose of demonstration. Avoid sleeping
                    // on thread-pool threads in real applications.
                    Thread.Sleep(1000);
                }

            }
            else
            {

// Display the specified message the specified number of times.
                for (int count = 0; count < config.Iterations; count++)
                {
                    Console.WriteLine(config.Message);

                    // Sleep for the purpose of demonstration. Avoid sleeping
                    // on thread-pool threads in real applications.
                    Thread.Sleep(1000);
                }
            }
        }

        public static void Main()
        {
            // Execute DisplayMessage using the thread pool and no arguments.
            ThreadPool.QueueUserWorkItem(DisplayMessage);

            // Create a MessageInfo object to pass to the DisplayMessage method.
            MessageInfo info = new MessageInfo(5,
                "A thread pool example with arguments.");

            // Set the max number of threads.
            ThreadPool.SetMaxThreads(2, 2);

            // Execute DisplayMessage using the thread pool and providing an
            // argument.
            ThreadPool.QueueUserWorkItem(DisplayMessage, info);

            // Wait to continue.
            Console.WriteLine("Main method complete. Press Enter.");
            Console.ReadLine();
        }
    }
}

The following code demonstrates how to use the asynchronous execution pattern. It uses a delegate named AsyncExampleDelegate to execute a method named LongRunningMethod asynchronously. LongRunningMethod simulates a long-running method using a configurable delay (produced using Thread.Sleep). The example contains the following five methods, which demonstrate the various approaches to handling asynchronous method completion:

using System;
using System.Threading;
using System.Collections;

namespace Apress.VisualCSharpRecipes.Chapter04
{
    class Recipe04_02
    {
        // A utility method for displaying useful trace information to the
        // console along with details of the current thread.
        private static void TraceMsg(DateTime time, string msg)
        {
            Console.WriteLine("[{0,3}/{1}] - {2} : {3}",
                Thread.CurrentThread.ManagedThreadId,
                Thread.CurrentThread.IsThreadPoolThread ? "pool" : "fore",
                time.ToString("HH:mm:ss.ffff"), msg);
        }

        // A delegate that allows you to perform asynchronous execution of
        // LongRunningMethod.

public delegate DateTime AsyncExampleDelegate(int delay, string name);

        // A simulated long-running method.
        public static DateTime LongRunningMethod(int delay, string name)
        {
            TraceMsg(DateTime.Now, name + " example - thread starting.");

            // Simulate time-consuming processing.
            Thread.Sleep(delay);

            TraceMsg(DateTime.Now, name + " example - thread stopping.");

            // Return the method's completion time.
            return DateTime.Now;
        }

        // This method executes LongRunningMethod asynchronously and continues
        // with other processing. Once the processing is complete, the method
        // blocks until LongRunningMethod completes.
        public static void BlockingExample()
        {
            Console.WriteLine(Environment.NewLine +
                "*** Running Blocking Example ***");

            // Invoke LongRunningMethod asynchronously. Pass null for both the
            // callback delegate and the asynchronous state object.
            AsyncExampleDelegate longRunningMethod = LongRunningMethod;

            IAsyncResult asyncResult = longRunningMethod.BeginInvoke(2000,
                "Blocking", null, null);

            // Perform other processing until ready to block.
            for (int count = 0; count < 3; count++)
            {
                TraceMsg(DateTime.Now,
                    "Continue processing until ready to block...");

                Thread.Sleep(200);
            }

            // Block until the asynchronous method completes.
            TraceMsg(DateTime.Now,
                "Blocking until method is complete...");

            // Obtain the completion data for the asynchronous method.
            DateTime completion = DateTime.MinValue;

            try
            {
                completion = longRunningMethod.EndInvoke(asyncResult);
            }

catch
            {
                // Catch and handle those exceptions you would if calling
                // LongRunningMethod directly.
            }

            // Display completion information.
            TraceMsg(completion,"Blocking example complete.");
        }

        // This method executes LongRunningMethod asynchronously and then
        // enters a polling loop until LongRunningMethod completes.
        public static void PollingExample()
        {
            Console.WriteLine(Environment.NewLine +
                "*** Running Polling Example ***");

            // Invoke LongRunningMethod asynchronously. Pass null for both the
            // callback delegate and the asynchronous state object.
            AsyncExampleDelegate longRunningMethod = LongRunningMethod;

            IAsyncResult asyncResult = longRunningMethod.BeginInvoke(2000,
                "Polling", null, null);

            // Poll the asynchronous method to test for completion. If not
            // complete, sleep for 300 ms before polling again.
            TraceMsg(DateTime.Now, "Poll repeatedly until method is complete.");

            while (!asyncResult.IsCompleted)
            {
                TraceMsg(DateTime.Now, "Polling...");
                Thread.Sleep(300);
            }

            // Obtain the completion data for the asynchronous method.
            DateTime completion = DateTime.MinValue;

            try
            {
                completion = longRunningMethod.EndInvoke(asyncResult);
            }
            catch
            {
                // Catch and handle those exceptions you would if calling
                // LongRunningMethod directly.
            }

            // Display completion information.
            TraceMsg(completion, "Polling example complete.");
        }

// This method executes LongRunningMethod asynchronously and then
        // uses a WaitHandle to wait efficiently until LongRunningMethod
        // completes. Use of a timeout allows the method to break out of
        // waiting in order to update the user interface or fail if the
        // asynchronous method is taking too long.
        public static void WaitingExample()
        {
            Console.WriteLine(Environment.NewLine +
                "*** Running Waiting Example ***");

            // Invoke LongRunningMethod asynchronously. Pass null for both the
            // callback delegate and the asynchronous state object.
            AsyncExampleDelegate longRunningMethod = LongRunningMethod;

            IAsyncResult asyncResult = longRunningMethod.BeginInvoke(2000,
                "Waiting", null, null);

            // Wait for the asynchronous method to complete. Time out after
            // 300 ms and display status to the console before continuing to
            // wait.
            TraceMsg(DateTime.Now, "Waiting until method is complete...");

            while (!asyncResult.AsyncWaitHandle.WaitOne(300, false))
            {
                TraceMsg(DateTime.Now, "Wait timeout...");
            }

            // Obtain the completion data for the asynchronous method.
            DateTime completion = DateTime.MinValue;

            try
            {
                completion = longRunningMethod.EndInvoke(asyncResult);
            }
            catch
            {
                // Catch and handle those exceptions you would if calling
                // LongRunningMethod directly.
            }

            // Display completion information.
            TraceMsg(completion, "Waiting example complete.");
        }

        // This method executes LongRunningMethod asynchronously multiple
        // times and then uses an array of WaitHandle objects to wait
        // efficiently until all of the methods are complete. Use of
        // a timeout allows the method to break out of waiting in order
        // to update the user interface or fail if the asynchronous
        // method is taking too long.

public static void WaitAllExample()
        {
            Console.WriteLine(Environment.NewLine +
                "*** Running WaitAll Example ***");

            // An ArrayList to hold the IAsyncResult instances for each of the
            // asynchronous methods started.
            ArrayList asyncResults = new ArrayList(3);

            // Invoke three LongRunningMethods asynchronously. Pass null for
            // both the callback delegate and the asynchronous state object.
            // Add the IAsyncResult instance for each method to the ArrayList.
            AsyncExampleDelegate longRunningMethod = LongRunningMethod;

            asyncResults.Add(longRunningMethod.BeginInvoke(3000,
                "WaitAll 1", null, null));

            asyncResults.Add(longRunningMethod.BeginInvoke(2500,
                "WaitAll 2", null, null));

            asyncResults.Add(longRunningMethod.BeginInvoke(1500,
                "WaitAll 3", null, null));

            // Create an array of WaitHandle objects that will be used to wait
            // for the completion of all the asynchronous methods.
            WaitHandle[] waitHandles = new WaitHandle[3];

            for (int count = 0; count < 3; count++)
            {
                waitHandles[count] =
                    ((IAsyncResult)asyncResults[count]).AsyncWaitHandle;
            }

            // Wait for all three asynchronous method to complete. Time out
            // after 300 ms and display status to the console before continuing
            // to wait.
            TraceMsg(DateTime.Now, "Waiting until all 3 methods are complete...");

            while (!WaitHandle.WaitAll(waitHandles, 300, false))
            {
                TraceMsg(DateTime.Now, "WaitAll timeout...");
            }

            // Inspect the completion data for each method, and determine the
            // time at which the final method completed.
            DateTime completion = DateTime.MinValue;

foreach (IAsyncResult result in asyncResults)
            {
                try
                {
                    DateTime time = longRunningMethod.EndInvoke(result);
                    if (time > completion) completion = time;
                }
                catch
                {
                    // Catch and handle those exceptions you would if calling
                    // LongRunningMethod directly.
                }
            }

            // Display completion information.
            TraceMsg(completion, "WaitAll example complete.");
        }

        // This method executes LongRunningMethod asynchronously and passes
        // an AsyncCallback delegate instance. The referenced CallbackHandler
        // method is called automatically when the asynchronous method
        // completes, leaving this method free to continue processing.
        public static void CallbackExample()
        {
            Console.WriteLine(Environment.NewLine +
                "*** Running Callback Example ***");

            // Invoke LongRunningMethod asynchronously. Pass an AsyncCallback
            // delegate instance referencing the CallbackHandler method that
            // will be called automatically when the asynchronous method
            // completes. Pass a reference to the AsyncExampleDelegate delegate
            // instance as asynchronous state; otherwise, the callback method
            // has no access to the delegate instance in order to call
            // EndInvoke.
            AsyncExampleDelegate longRunningMethod = LongRunningMethod;

            IAsyncResult asyncResult = longRunningMethod.BeginInvoke(2000,
                "Callback", CallbackHandler, longRunningMethod);

            // Continue with other processing.
            for (int count = 0; count < 15; count++)
            {
                TraceMsg(DateTime.Now, "Continue processing...");
                Thread.Sleep(200);
            }
        }

        // A method to handle asynchronous completion using callbacks.
        public static void CallbackHandler(IAsyncResult result)
        {

// Extract the reference to the AsyncExampleDelegate instance
            // from the IAsyncResult instance. This allows you to obtain the
            // completion data.
            AsyncExampleDelegate longRunningMethod =
                (AsyncExampleDelegate)result.AsyncState;

            // Obtain the completion data for the asynchronous method.
            DateTime completion = DateTime.MinValue;

            try
            {
                completion = longRunningMethod.EndInvoke(result);
            }
            catch
            {
                // Catch and handle those exceptions you would if calling
                // LongRunningMethod directly.
            }

            // Display completion information.
            TraceMsg(completion, "Callback example complete.");
        }

        public static void Main()
        {
            // Demonstrate the various approaches to asynchronous method completion.
            BlockingExample();
            PollingExample();
            WaitingExample();
            WaitAllExample();
            CallbackExample();

            // Wait to continue.
            Console.WriteLine(Environment.NewLine);
            Console.WriteLine("Main method complete. Press Enter.");
            Console.ReadLine();
        }
    }
}

The TimerExample class shown next demonstrates how to use a Timer object to call a method named TimerHandler. Initially, the Timer object is configured to call TimerHandler after 2 seconds and then at 1-second intervals. The example allows you to enter a new millisecond interval in the console, which is applied using the Timer.Change method.

using System;
using System.Threading;

namespace Apress.VisualCSharpRecipes.Chapter04
{
    class Recipe04_03
    {
        public static void Main()
        {
            // Create the state object that is passed to the TimerHandler
            // method when it is triggered. In this case, a message to display.
            string state = "Timer expired.";

            Console.WriteLine("{0} : Creating Timer.",
                DateTime.Now.ToString("HH:mm:ss.ffff"));

            // Create a timer that fires first after 2 seconds and then every
            // second. Use an anonymous method for the timer expiry handler.
            using (Timer timer =
                new Timer(delegate(object s)
                            {Console.WriteLine("{0} : {1}",
                             DateTime.Now.ToString("HH:mm:ss.ffff"),s);
                            }
                , state, 2000, 1000))
            {
                int period;

                // Read the new timer interval from the console until the
                // user enters 0 (zero). Invalid values use a default value
                // of 0, which will stop the example.
                do
                {
                    try
                    {
                        period = Int32.Parse(Console.ReadLine());
                    }
                    catch (FormatException)
                    {
                        period = 0;
                    }

                    // Change the timer to fire using the new interval starting
                    // immediately.
                    if (period > 0) timer.Change(0, period);
                } while (period > 0);
            }

// Wait to continue.
            Console.WriteLine("Main method complete. Press Enter.");
            Console.ReadLine();
        }
    }
}

The following code demonstrates how to use a Timer object to execute a method at a specified time:

using System;
using System.Threading;
using System.Globalization;

namespace Apress.VisualCSharpRecipes.Chapter04
{
    class Recipe04_04
    {
        public static void Main(string[] args)
        {
            // Create a 30-second timespan.
            TimeSpan waitTime = new TimeSpan(0, 0, 30);

            // Create a Timer that fires once at the specified time. Specify
            // an interval of −1 to stop the timer executing the method
            // repeatedly. Use an anonymouse method for the timer expiry handler.
            new Timer(delegate(object s)
            {
                Console.WriteLine("Timer fired at {0}",
                DateTime.Now.ToString("HH:mm:ss.ffff"));
            }
                      , null, waitTime, new TimeSpan(-1));

            Console.WriteLine("Waiting for timer. Press Enter to terminate.");
            Console.ReadLine();
        }
    }
}

The following example demonstrates how to use an AutoResetEvent to trigger the execution of a method named EventHandler. (The AutoResetEvent class is discussed further in recipe 4-8.)

using System;
using System.Threading;

namespace Apress.VisualCSharpRecipes.Chapter04
{
    class Recipe04_05
    {
        // A method that is executed when the AutoResetEvent is signaled
        // or the wait operation times out.
        private static void EventHandler(object state, bool timedout)
        {
            // Display appropriate message to the console based on whether
            // the wait timed out or the AutoResetEvent was signaled.
            if (timedout)
            {
                Console.WriteLine("{0} : Wait timed out.",
                    DateTime.Now.ToString("HH:mm:ss.ffff"));
            }
            else
            {
                Console.WriteLine("{0} : {1}",
                    DateTime.Now.ToString("HH:mm:ss.ffff"), state);
            }
        }

        public static void Main()
        {
            // Create the new AutoResetEvent in an unsignaled state.
            AutoResetEvent autoEvent = new AutoResetEvent(false);

            // Create the state object that is passed to the event handler
            // method when it is triggered. In this case, a message to display.
            string state = "AutoResetEvent signaled.";

            // Register the EventHandler method to wait for the AutoResetEvent to
            // be signaled. Set a timeout of 10 seconds, and configure the wait
            // operation to reset after activation (last argument).

RegisteredWaitHandle handle = ThreadPool.RegisterWaitForSingleObject(
                autoEvent, EventHandler, state, 10000, false);

            Console.WriteLine("Press ENTER to signal the AutoResetEvent" +
                " or enter "Cancel" to unregister the wait operation.");

            while (Console.ReadLine().ToUpper() != "CANCEL")
            {
                // If "Cancel" has not been entered into the console, signal
                // the AutoResetEvent, which will cause the EventHandler
                // method to execute. The AutoResetEvent will automatically
                // revert to an unsignaled state.
                autoEvent.Set();
            }

            // Unregister the wait operation.
            Console.WriteLine("Unregistering wait operation.");
            handle.Unregister(null);

            // Wait to continue.
            Console.WriteLine("Main method complete. Press Enter.");
            Console.ReadLine();
        }
    }
}

The following code demonstrates how to execute a method in a new thread and shows you how to pass data to the new thread:

using System;
using System.Threading;

namespace Apress.VisualCSharpRecipes.Chapter04
{
    class Recipe04_06
    {

        // A utility method for displaying useful trace information to the
        // console along with details of the current thread.
        private static void TraceMsg(string msg)
        {
            Console.WriteLine("[{0,3}] - {1} : {2}",
                Thread.CurrentThread.ManagedThreadId,
                DateTime.Now.ToString("HH:mm:ss.ffff"), msg);
        }

        // A private class used to pass initialization data to a new thread.
        private class ThreadStartData
        {
            public ThreadStartData(int iterations, string message, int delay)
            {
                this.iterations = iterations;

this.message = message;
                this.delay = delay;
            }

            // Member variables hold initialization data for a new thread.
            private readonly int iterations;
            private readonly string message;
            private readonly int delay;

            // Properties provide read-only access to initialization data.
            public int Iterations { get { return iterations; } }
            public string Message { get { return message; } }
            public int Delay { get { return delay; } }
        }

        // Declare the method that will be executed in its own thread. The
        // method displays a message to the console a specified number of
        // times, sleeping between each message for a specified duration.
        private static void DisplayMessage(object config)
        {
            ThreadStartData data = config as ThreadStartData;

            if (data != null)
            {
                for (int count = 0; count < data.Iterations; count++)
                {
                    TraceMsg(data.Message);

                    // Sleep for the specified period.
                    Thread.Sleep(data.Delay);
                }
            }
            else
            {
                TraceMsg("Invalid thread configuration.");
            }
        }

        public static void Main()
        {
            // Create a new Thread object specifying DisplayMessage
            // as the method it will execute.
            Thread thread = new Thread(DisplayMessage);
            // Make this a foreground thread - this is the
            // default - call used for example purposes.
            thread.IsBackground = false;

            // Create a new ThreadStartData object to configure the thread.
            ThreadStartData config =
                new ThreadStartData(5, "A thread example.", 500);
            TraceMsg("Starting new thread.");

// Start the new thread and pass the ThreadStartData object
            // containing the initialization data.
            thread.Start(config);

            // Continue with other processing.
            for (int count = 0; count < 13; count++)
            {
                TraceMsg("Main thread continuing processing...");
                Thread.Sleep(200);
            }

            // Wait to continue.
            Console.WriteLine(Environment.NewLine);
            Console.WriteLine("Main method complete. Press Enter.");
            Console.ReadLine();
        }
    }
}

The following example demonstrates how to synchronize access to a shared resource (the console) and the activation of waiting threads using the Monitor.Wait, Monitor.Pulse, and Monitor.PulseAll methods. The example starts three worker threads that take work items from a queue and processes them. When the user presses Enter the first two times, work items (strings in the example) are added to the work queue, and Monitor.Pulse is called to release one waiting thread for each work item. The third time the user presses Enter, Monitor.PulseAll is called, releasing all waiting threads and allowing them to terminate.

using System;
using System.Threading;
using System.Collections.Generic;

namespace Apress.VisualCSharpRecipes.Chapter04
{
    class Recipe04_07
    {
        // Declare an object for synchronization of access to the console.
        // A static object is used because you are using it in static methods.
        private static object consoleGate = new Object();

        // Declare a Queue to represent the work queue.
        private static Queue<string> workQueue = new Queue<string>();

        // Declare a flag to indicate to activated threads that they should
        // terminate and not process more work items.
        private static bool processWorkItems = true;

        // A utility method for displaying useful trace information to the
        // console along with details of the current thread.
        private static void TraceMsg(string msg)
        {
            lock (consoleGate)
            {

Console.WriteLine("[{0,3}/{1}] - {2} : {3}",
                    Thread.CurrentThread.ManagedThreadId,
                    Thread.CurrentThread.IsThreadPoolThread ? "pool" : "fore",
                    DateTime.Now.ToString("HH:mm:ss.ffff"), msg);
            }
        }

        // Declare the method that will be executed by each thread to process
        // items from the work queue.
        private static void ProcessWorkItems()
        {
            // A local variable to hold the work item taken from the work queue.
            string workItem = null;

            TraceMsg("Thread started, processing items from queue...");

            // Process items from the work queue until termination is signaled.
            while (processWorkItems)
            {
                // Obtain the lock on the work queue.
                Monitor.Enter(workQueue);

                try
                {
                    // Pop the next work item and process it, or wait if none
                    // is available.
                    if (workQueue.Count == 0)
                    {
                        TraceMsg("No work items, waiting...");

                        // Wait until Pulse is called on the workQueue object.
                        Monitor.Wait(workQueue);
                    }
                    else
                    {
                        // Obtain the next work item.
                        workItem = workQueue.Dequeue();
                    }
                }
                finally
                {
                    // Always release the lock.
                    Monitor.Exit(workQueue);
                }

                // Process the work item if one was obtained.
                if (workItem != null)
                {

// Obtain a lock on the console and display a series
                    // of messages.
                    lock (consoleGate)
                    {
                        for (int i = 0; i < 5; i++)
                        {
                            TraceMsg("Processing " + workItem);
                            Thread.Sleep(200);
                        }
                    }

                    // Reset the status of the local variable.
                    workItem = null;
                }
            }

            // This will be reached only if processWorkItems is false.
            TraceMsg("Terminating.");
        }

        public static void Main()
        {
            TraceMsg("Starting worker threads.");

            // Add an initial work item to the work queue.
            lock (workQueue)
            {
                workQueue.Enqueue("Work Item 1");
            }

            // Create and start three new worker threads running the
            // ProcessWorkItems method.
            for (int count = 0; count < 3; count++)
            {
                (new Thread(ProcessWorkItems)).Start();
            }

            Thread.Sleep(1500);

            // The first time the user presses Enter, add a work item and
            // activate a single thread to process it.
            TraceMsg("Press Enter to pulse one waiting thread.");
            Console.ReadLine();

            // Acquire a lock on the workQueue object.
            lock (workQueue)
            {
                // Add a work item.
                workQueue.Enqueue("Work Item 2.");

// Pulse one waiting thread.
                Monitor.Pulse(workQueue);
            }

            Thread.Sleep(2000);

            // The second time the user presses Enter, add three work items and
            // activate three threads to process them.
            TraceMsg("Press Enter to pulse three waiting threads.");
            Console.ReadLine();

            // Acquire a lock on the workQueue object.
            lock (workQueue)
            {
                // Add work items to the work queue, and activate worker threads.
                workQueue.Enqueue("Work Item 3.");
                Monitor.Pulse(workQueue);
                workQueue.Enqueue("Work Item 4.");
                Monitor.Pulse(workQueue);
                workQueue.Enqueue("Work Item 5.");
                Monitor.Pulse(workQueue);
            }

            Thread.Sleep(3500);

            // The third time the user presses Enter, signal the worker threads
            // to terminate and activate them all.
            TraceMsg("Press Enter to pulse all waiting threads.");
            Console.ReadLine();

            // Acquire a lock on the workQueue object.
            lock (workQueue)
            {
                // Signal that threads should terminate.
                processWorkItems = false;

                // Pulse all waiting threads.
                Monitor.PulseAll(workQueue);
            }

            Thread.Sleep(1000);

            // Wait to continue.
            TraceMsg("Main method complete. Press Enter.");
            Console.ReadLine();
        }
    }
}

The following example demonstrates how to use a named EventWaitHandle in manual mode that is initially signaled. A thread is spawned that waits on the event and then displays a message to the console—repeating the process every 2 seconds. When you press Enter, you toggle the event between a signaled and a unsignaled state. This example uses the Thread.Join instance method, which we describe in recipe 4-12.

using System;
using System.Threading;

namespace Apress.VisualCSharpRecipes.Chapter04
{
    class Recipe04_08
    {
        // Boolean to signal that the second thread should terminate.
        static bool terminate = false;

        // A utility method for displaying useful trace information to the
        // console along with details of the current thread.

private static void TraceMsg(string msg)
        {
            Console.WriteLine("[{0,3}] - {1} : {2}",
                Thread.CurrentThread.ManagedThreadId,
                DateTime.Now.ToString("HH:mm:ss.ffff"), msg);
        }

        // Declare the method that will be executed on the separate thread.
        // The method waits on the EventWaitHandle before displaying a message
        // to the console and then waits two seconds and loops.
        private static void DisplayMessage()
        {
            // Obtain a handle to the EventWaitHandle with the name "EventExample".
            EventWaitHandle eventHandle =
                EventWaitHandle.OpenExisting("EventExample");

            TraceMsg("DisplayMessage Started.");

            while (!terminate)
            {
                // Wait on the EventWaitHandle, time out after 2 seconds. WaitOne
                // returns true if the event is signaled; otherwise, false. The
                // first time through, the message will be displayed immediately
                // because the EventWaitHandle was created in a signaled state.
                if (eventHandle.WaitOne(2000, true))
                {
                    TraceMsg("EventWaitHandle In Signaled State.");
                }
                else
                {
                    TraceMsg("WaitOne Timed Out -- " +
                        "EventWaitHandle In Unsignaled State.");
                }
                Thread.Sleep(2000);
            }

            TraceMsg("Thread Terminating.");
        }

        public static void Main()
        {
            // Create a new EventWaitHandle with an initial signaled state, in
            // manual mode, with the name "EventExample".
            using (EventWaitHandle eventWaitHandle =
                new EventWaitHandle(true, EventResetMode.ManualReset,
                "EventExample"))
            {

// Create and start a new thread running the DisplayMesssage
                // method.
                TraceMsg("Starting DisplayMessageThread.");
                Thread trd = new Thread(DisplayMessage);
                trd.Start();

                // Allow the EventWaitHandle to be toggled between a signaled and
                // unsignaled state up to three times before ending.
                for (int count = 0; count < 3; count++)
                {
                    // Wait for Enter to be pressed.
                    Console.ReadLine();

                    // You need to toggle the event. The only way to know the
                    // current state is to wait on it with a 0 (zero) timeout
                    // and test the result.
                    if (eventWaitHandle.WaitOne(0, true))
                    {
                        TraceMsg("Switching Event To UnSignaled State.");

                        // Event is signaled, so unsignal it.
                        eventWaitHandle.Reset();
                    }
                    else
                    {
                        TraceMsg("Switching Event To Signaled State.");

                        // Event is unsignaled, so signal it.
                        eventWaitHandle.Set();
                    }
                }

                // Terminate the DisplayMessage thread, and wait for it to
                // complete before disposing of the EventWaitHandle.
                terminate = true;
                eventWaitHandle.Set();
                trd.Join(5000);
            }

            // Wait to continue.
            Console.WriteLine(Environment.NewLine);
            Console.WriteLine("Main method complete. Press Enter.");
            Console.ReadLine();
        }
    }
}

The following example demonstrates how to use a named Mutex to limit access to a shared resource (the console) to a single thread at any given time:

using System;
using System.Threading;

namespace Apress.VisualCSharpRecipes.Chapter04
{
    class Recipe04_09
    {

// Boolean to signal that the second thread should terminate.
        static bool terminate = false;

        // A utility method for displaying useful trace information to the
        // console along with details of the current thread.
        private static void TraceMsg(string msg)
        {
            Console.WriteLine("[{0,3}] - {1} : {2}",
                Thread.CurrentThread.ManagedThreadId,
                DateTime.Now.ToString("HH:mm:ss.ffff"), msg);
        }

        // Declare the method that will be executed on the separate thread.
        // In a loop the method waits to obtain a Mutex before displaying a
        // message to the console and then waits 1 second before releasing the
        // Mutex.
        private static void DisplayMessage()
        {
            // Obtain a handle to the Mutex with the name "MutexExample".
            // Do not attempt to take ownership immediately.
            using (Mutex mutex = new Mutex(false, "MutexExample"))
            {
                TraceMsg("Thread started.");

                while (!terminate)
                {
                    // Wait on the Mutex.
                    mutex.WaitOne();

                    TraceMsg("Thread owns the Mutex.");

                    Thread.Sleep(1000);

                    TraceMsg("Thread releasing the Mutex.");

                    // Release the Mutex.
                    mutex.ReleaseMutex();

                    // Sleep a little to give another thread a good chance of
                    // acquiring the Mutex.
                    Thread.Sleep(100);
                }

                TraceMsg("Thread terminating.");
            }
        }

public static void Main()
        {
            // Create a new Mutex with the name "MutexExample".
            using (Mutex mutex = new Mutex(false, "MutexExample"))
            {
                TraceMsg("Starting threads -- press Enter to terminate.");

                // Create and start three new threads running the
                // DisplayMesssage method.
                Thread trd1 = new Thread(DisplayMessage);
                Thread trd2 = new Thread(DisplayMessage);
                Thread trd3 = new Thread(DisplayMessage);
                trd1.Start();
                trd2.Start();
                trd3.Start();

                // Wait for Enter to be pressed.
                Console.ReadLine();

                // Terminate the DisplayMessage threads, and wait for them to
                // complete before disposing of the Mutex.
                terminate = true;
                trd1.Join(5000);
                trd2.Join(5000);
                trd3.Join(5000);
            }

            // Wait to continue.
            Console.WriteLine(Environment.NewLine);
            Console.WriteLine("Main method complete. Press Enter.");
            Console.ReadLine();
        }
    }
}

The following example demonstrates how to use a named Semaphore to limit access to a shared resource (the console) to two threads at any given time. The code is similar to that used in recipe 4-9 but substitutes a Semaphore for the Mutex.

using System;
using System.Threading;

namespace Apress.VisualCSharpRecipes.Chapter04
{
    class Recipe04_10
    {
        // Boolean to signal that the second thread should terminate.
        static bool terminate = false;

// A utility method for displaying useful trace information to the
        // console along with details of the current thread.
        private static void TraceMsg(string msg)
        {
            Console.WriteLine("[{0,3}] - {1} : {2}",
                Thread.CurrentThread.ManagedThreadId,
                DateTime.Now.ToString("HH:mm:ss.ffff"), msg);
        }

        // Declare the method that will be executed on the separate thread.
        // In a loop the method waits to obtain a Semaphore before displaying a
        // message to the console and then waits 1 second before releasing the
        // Semaphore.
        private static void DisplayMessage()
        {
            // Obtain a handle to the Semaphore with the name "SemaphoreExample".
            using (Semaphore sem = Semaphore.OpenExisting("SemaphoreExample"))
            {
                TraceMsg("Thread started.");

                while (!terminate)
                {
                    // Wait on the Semaphore.
                    sem.WaitOne();

                    TraceMsg("Thread owns the Semaphore.");

                    Thread.Sleep(1000);

                    TraceMsg("Thread releasing the Semaphore.");

                    // Release the Semaphore.
                    sem.Release();

                    // Sleep a little to give another thread a good chance of
                    // acquiring the Semaphore.
                    Thread.Sleep(100);
                }

                TraceMsg("Thread terminating.");
            }
        }

        public static void Main()
        {
            // Create a new Semaphore with the name "SemaphoreExample". The
            // Semaphore can be owned by up to two threads at the same time.
            using (Semaphore sem = new Semaphore(2,2,"SemaphoreExample"))
            {
                TraceMsg("Starting threads -- press Enter to terminate.");

// Create and start three new threads running the
                // DisplayMesssage method.
                Thread trd1 = new Thread(DisplayMessage);
                Thread trd2 = new Thread(DisplayMessage);
                Thread trd3 = new Thread(DisplayMessage);
                trd1.Start();
                trd2.Start();
                trd3.Start();

                // Wait for Enter to be pressed.
                Console.ReadLine();

                // Terminate the DisplayMessage threads and wait for them to
                // complete before disposing of the Semaphore.
                terminate = true;
                trd1.Join(5000);
                trd2.Join(5000);
                trd3.Join(5000);
            }

            // Wait to continue.
            Console.WriteLine(Environment.NewLine);
            Console.WriteLine("Main method complete. Press Enter.");
            Console.ReadLine();
        }
    }
}

The following simple example demonstrates how to use the methods of the Interlocked class. The example does not demonstrate Interlocked in the context of a multithreaded program and is provided only to clarify the syntax and effect of the various methods.

using System;
using System.Threading;

namespace Apress.VisualCSharpRecipes.Chapter04
{
    class Recipe04_11
    {
        public static void Main()
        {
            int firstInt = 2500;
            int secondInt = 8000;

Console.WriteLine("firstInt initial value = {0}", firstInt);
            Console.WriteLine("secondInt initial value = {0}", secondInt);

            // Decrement firstInt in a thread-safe manner.
            // The thread-safe equivalent of firstInt = firstInt - 1.
            Interlocked.Decrement(ref firstInt);

            Console.WriteLine(Environment.NewLine);
            Console.WriteLine("firstInt after decrement = {0}", firstInt);

            // Increment secondInt in a thread-safe manner.
            // The thread-safe equivalent of secondInt = secondInt + 1.
            Interlocked.Increment(ref secondInt);

            Console.WriteLine("secondInt after increment = {0}", secondInt);

            // Add the firstInt and secondInt values, and store the result in
            // firstInt.
            // The thread-safe equivalent of firstInt = firstInt + secondInt.
            Interlocked.Add(ref firstInt, secondInt);

            Console.WriteLine(Environment.NewLine);
            Console.WriteLine("firstInt after Add = {0}", firstInt);
            Console.WriteLine("secondInt after Add = {0}", secondInt);

            // Exchange the value of firstInt with secondInt.
            // The thread-safe equivalenet of secondInt = firstInt.
            Interlocked.Exchange(ref secondInt, firstInt);

            Console.WriteLine(Environment.NewLine);
            Console.WriteLine("firstInt after Exchange = {0}", firstInt);
            Console.WriteLine("secondInt after Exchange = {0}", secondInt);

            // Compare firstInt with secondInt, and if they are equal, set
            // firstInt to 5000.
            // The thread-safe equivalenet of:
            //     if (firstInt == secondInt) firstInt = 5000.
            Interlocked.CompareExchange(ref firstInt, 5000, secondInt);

            Console.WriteLine(Environment.NewLine);
            Console.WriteLine("firstInt after CompareExchange = {0}", firstInt);
            Console.WriteLine("secondInt after CompareExchange = {0}", secondInt);

            // Wait to continue.
            Console.WriteLine(Environment.NewLine);
            Console.WriteLine("Main method complete. Press Enter.");
            Console.ReadLine();
        }
    }
}

The following example executes a second thread and then calls Join (with a timeout of 2 seconds) to wait for the second thread to terminate. Because the second thread takes about 5 seconds to execute, the Join method will always time out, and the example will display a message to the console. The example then calls Join again without a timeout and blocks until the second thread terminates.

using System;
using System.Threading;

namespace Apress.VisualCSharpRecipes.Chapter04
{
    class Recipe04_12
    {
        private static void DisplayMessage()
        {
            // Display a message to the console five times.
            for (int count = 0; count < 5; count++)
            {
                Console.WriteLine("{0} : DisplayMessage thread",
                    DateTime.Now.ToString("HH:mm:ss.ffff"));

// Sleep for 1 second.
                Thread.Sleep(1000);
            }
        }

        public static void Main()
        {
            // Create a new Thread to run the DisplayMessage method.
            Thread thread = new Thread(DisplayMessage);

            Console.WriteLine("{0} : Starting DisplayMessage thread.",
                DateTime.Now.ToString("HH:mm:ss.ffff"));

            // Start the DisplayMessage thread.
            thread.Start();

            // Block until the DisplayMessage thread finishes, or time out after
            // 2 seconds.
            if (!thread.Join(2000))
            {
                Console.WriteLine("{0} : Join timed out !!",
                    DateTime.Now.ToString("HH:mm:ss.ffff"));
            }

            // Print out the thread status.
            Console.WriteLine("Thread alive: {0}", thread.IsAlive);

            // Block again until the DisplayMessage thread finishes with no timeout.
            thread.Join();

            // Print out the thread status.
            Console.WriteLine("Thread alive: {0}", thread.IsAlive);

            // Wait to continue.
            Console.WriteLine("Main method complete. Press Enter.");
            Console.ReadLine();
        }
    }
}

The following example creates a new thread that continues to display messages to the console until you press Enter, at which point the thread is terminated by a call to Thread.Abort:

using System;
using System.Threading;

namespace Apress.VisualCSharpRecipes.Chapter04
{
    class Recipe04_13
    {
        private static void DisplayMessage()
        {
            try
            {
                while (true)
                {
                    // Display a message to the console.
                    Console.WriteLine("{0} : DisplayMessage thread active",
                        DateTime.Now.ToString("HH:mm:ss.ffff"));

                    // Sleep for 1 second.
                    Thread.Sleep(1000);
                }
            }

catch (ThreadAbortException ex)
            {
                // Display a message to the console.
                Console.WriteLine("{0} : DisplayMessage thread terminating - {1}",
                    DateTime.Now.ToString("HH:mm:ss.ffff"),
                    (string)ex.ExceptionState);

                // Call Thread.ResetAbort here to cancel the abort request.
            }

            // This code is never executed unless Thread.ResetAbort
            // is called in the previous catch block.
            Console.WriteLine("{0} : nothing is called after the catch block",
                DateTime.Now.ToString("HH:mm:ss.ffff"));
        }

        public static void Main()
        {
            // Create a new Thread to run the DisplayMessage method.
            Thread thread = new Thread(DisplayMessage);

            Console.WriteLine("{0} : Starting DisplayMessage thread" +
                " - press Enter to terminate.",
                DateTime.Now.ToString("HH:mm:ss.ffff"));

            // Start the DisplayMessage thread.
            thread.Start();

            // Wait until Enter is pressed and terminate the thread.
            Console.ReadLine();

            thread.Abort("User pressed Enter");

            // Block again until the DisplayMessage thread finishes.
            thread.Join();

            // Wait to continue.
            Console.WriteLine("Main method complete. Press Enter.");
            Console.ReadLine();
        }
    }
}

The following code snippet shows how to create a thread-safe Hashtable instance:

// Create a standard Hashtable.
Hashtable hUnsync = new Hashtable();

// Create a synchronized wrapper.
Hashtable hSync = Hashtable.Synchronized(hUnsync);

The following code snippet shows how to create a thread-safe NameValueCollection. Notice that the NameValueCollection class derives from the NameObjectCollectionBase class, which uses an explicit interface implementation to implement the ICollection.SyncRoot property. As shown, you must cast the NameValueCollection to an ICollection instance before you can access the SyncRoot property. Casting is not necessary with other specialized collection classes such as HybridDictionary, ListDictionary, and StringCollection, which do not use explicit interface implementations to implement SyncRoot.

// Create a NameValueCollection.
NameValueCollection nvCollection = new NameValueCollection();

// Obtain a lock on the NameValueCollection before modification.
lock (((ICollection)nvCollection).SyncRoot) {

    // Modify the NameValueCollection...
}

The following example uses Process to execute Notepad in a maximized window and open a file named C:Tempfile.txt. After creation, the example calls the Process.WaitForExit method, which blocks the calling thread until a process terminates or a specified timeout expires. This method returns true if the process ends before the timeout and returns false otherwise.

using System;
using System.Diagnostics;

namespace Apress.VisualCSharpRecipes.Chapter04
{
    class Recipe04_15
    {
        public static void Main()
        {
            // Create a ProcessStartInfo object and configure it with the
            // information required to run the new process.
            ProcessStartInfo startInfo = new ProcessStartInfo();

            startInfo.FileName = "notepad.exe";
            startInfo.Arguments = "file.txt";
            startInfo.WorkingDirectory = @"C:Temp";
            startInfo.WindowStyle = ProcessWindowStyle.Maximized;
            startInfo.ErrorDialog = true;

            // Declare a new Process object.
            Process process;

            try
            {
                // Start the new process.
                process = Process.Start(startInfo);

                // Wait for the new process to terminate before exiting.
                Console.WriteLine("Waiting 30 seconds for process to finish.");

                if (process.WaitForExit(30000))
                {
                    Console.WriteLine("Process terminated.");
                }
                else
                {
                    Console.WriteLine("Timed out waiting for process to end.");
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine("Could not start process.");
                Console.WriteLine(ex);
            }

// Wait to continue.
            Console.WriteLine(Environment.NewLine);
            Console.WriteLine("Main method complete. Press Enter.");
            Console.ReadLine();
        }
    }
}

The following example starts a new instance of Notepad, waits 5 seconds, and then terminates the Notepad process. The example first tries to terminate the process using CloseMainWindow. If CloseMainWindow returns false, or the Notepad process is still running after CloseMainWindow is called, the example calls Kill and forces the Notepad process to terminate; you can force CloseMainWindow to return false by leaving the File Open dialog box open.

using System;
using System.Threading;
using System.Diagnostics;

namespace Apress.VisualCSharpRecipes.Chapter04
{
    class Recipe04_16
    {
        public static void Main()
        {
            // Create a new Process and run notepad.exe.
            using (Process process =
                Process.Start("notepad.exe",@"c:SomeFile.txt"))
            {
                // Wait for 5 seconds and terminate the notepad process.
                Console.WriteLine(
                    "Waiting 5 seconds before terminating notepad.exe.");
                Thread.Sleep(5000);

                // Terminate notepad process.
                Console.WriteLine("Terminating Notepad with CloseMainWindow.");

// Try to send a close message to the main window.
                if (!process.CloseMainWindow())
                {
                    // Close message did not get sent - Kill Notepad.
                    Console.WriteLine("CloseMainWindow returned false - " +
                        " terminating Notepad with Kill.");
                    process.Kill();
                }
                else
                {
                    // Close message sent successfully; wait for 2 seconds
                    // for termination confirmation before resorting to Kill.
                    if (!process.WaitForExit(2000))
                    {
                        Console.WriteLine("CloseMainWindow failed to" +
                            " terminate - terminating Notepad with Kill.");
                        process.Kill();
                    }
                }
            }

            // Wait to continue.
            Console.WriteLine("Main method complete. Press Enter.");
            Console.ReadLine();
        }
    }
}

This example uses a Mutex named MutexExample to ensure that only a single instance of the example can execute:

using System;
using System.Threading;

namespace Apress.VisualCSharpRecipes.Chapter04
{
    class Recipe04_17
    {
        public static void Main()
        {
            // A Boolean that indicates whether this application has
            // initial ownership of the Mutex.
            bool ownsMutex;

            // Attempt to create and take ownership of a Mutex named
            // MutexExample.
            using (Mutex mutex =
                       new Mutex(true, "MutexExample", out ownsMutex))
            {
                // If the application owns the Mutex it can continue to execute;
                // otherwise, the application should exit.
                if (ownsMutex)
                {
                    Console.WriteLine("This application currently owns the" +
                        " mutex named MutexExample. Additional instances of" +
                        " this application will not run until you release" +
                        " the mutex by pressing Enter.");

                    Console.ReadLine();

                    // Release the mutex.
                    mutex.ReleaseMutex();
                }
                else
                {
                    Console.WriteLine("Another instance of this application " +
                        " already owns the mutex named MutexExample. This" +
                        " instance of the application will terminate.");
                }
            }

// Wait to continue.
            Console.WriteLine("Main method complete. Press Enter.");
            Console.ReadLine();
        }
    }
}