AutoResetEvent 2

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;

namespace WaitOne
{
    class Program
    {
        static void Main(string[] args)
        {
           Calculate calc = new Calculate();
        Console.WriteLine("Result = {0}.",
            calc.Result(234).ToString());
        Console.WriteLine("Result = {0}.",
            calc.Result(55).ToString());

        }

        static void WorkMethod(object stateInfo)
        {
            Console.WriteLine("Work starting.");

            // Simulate time spent working.
            Thread.Sleep(new Random().Next(100, 2000));

            // Signal that work is finished.
            Console.WriteLine("Work ending.");
            ((AutoResetEvent)stateInfo).Set();
        }

    }
    class Calculate
    {
        double baseNumber, firstTerm, secondTerm, thirdTerm;
        AutoResetEvent[] autoEvents;
        ManualResetEvent manualEvent;

        // Generate random numbers to simulate the actual calculations.
        Random randomGenerator;

        public Calculate()
        {
            autoEvents = new AutoResetEvent[]
        {
            new AutoResetEvent(false),
            new AutoResetEvent(false),
            new AutoResetEvent(false)
        };

            manualEvent = new ManualResetEvent(false);
        }

        void CalculateBase(object stateInfo)
        {
            baseNumber = randomGenerator.NextDouble();

            Console.WriteLine("Base start");
            // Signal that baseNumber is ready.
            manualEvent.Set();

            Console.WriteLine("Base work");
        }

        // The following CalculateX methods all perform the same
        // series of steps as commented in CalculateFirstTerm.

        void CalculateFirstTerm(object stateInfo)
        {
            // Perform a precalculation.
            double preCalc = randomGenerator.NextDouble();

            Console.WriteLine("First start");
            // Wait for baseNumber to be calculated.
            manualEvent.WaitOne();

            Console.WriteLine("First work.");
            // Calculate the first term from preCalc and baseNumber.
            firstTerm = preCalc * baseNumber *
                randomGenerator.NextDouble();

            // Signal that the calculation is finished.
            autoEvents[0].Set();
        }

        void CalculateSecondTerm(object stateInfo)
        {
            double preCalc = randomGenerator.NextDouble();
            Console.WriteLine("Second Start..");
            manualEvent.WaitOne();
            Console.WriteLine("Second Work..");
            secondTerm = preCalc * baseNumber *
                randomGenerator.NextDouble();
            autoEvents[1].Set();
        }

        void CalculateThirdTerm(object stateInfo)
        {
            double preCalc = randomGenerator.NextDouble();
            Console.WriteLine("Third Start..");
            manualEvent.WaitOne();

            Console.WriteLine("Third work..");
            thirdTerm = preCalc * baseNumber *
                randomGenerator.NextDouble();
            autoEvents[2].Set();
        }

        public double Result(int seed)
        {
            randomGenerator = new Random(seed);

            // Simultaneously calculate the terms.
            ThreadPool.QueueUserWorkItem(
                new WaitCallback(CalculateBase));
            ThreadPool.QueueUserWorkItem(
                new WaitCallback(CalculateFirstTerm));
            ThreadPool.QueueUserWorkItem(
                new WaitCallback(CalculateSecondTerm));
            ThreadPool.QueueUserWorkItem(
                new WaitCallback(CalculateThirdTerm));

            // Wait for all of the terms to be calculated.
            WaitHandle.WaitAll(autoEvents);

            // Reset the wait handle for the next calculation.
            manualEvent.Reset();

            return firstTerm + secondTerm + thirdTerm;
        }
    }
}