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

public class MulticurrencyExchanger
{
    static List conversions;

    static MulticurrencyExchanger()
    {
        // The conversion factors
        conversions = new List();
        conversions.Add(new ConversionInfo("USD", "RS", 40.00));
        conversions.Add(new ConversionInfo("EURO", "RS", 47.00));
        conversions.Add(new ConversionInfo("GBP", "RS", 73.00));
    }

    Random random = new Random();

    public void Init()
    {
        Action action = UpdateConversionFactors;

        // Loop infinitely
        while (true)
        {
            int waitTime = random.Next(1000, 5000);
            Thread.Sleep(waitTime);

            lock (conversions)
            {
                // Apply conversion on the conversion list
                conversions.ForEach(action);
            }
        }
    }

    // Wrapper method to apply updated conversion rates 
    void UpdateConversionFactors(ConversionInfo info)
    {
        int percentage = random.Next(-5, 5);
        info.conversionFactor = info.conversionFactor * (1 + (double)percentage / 100);
    }

    // Service method to do a conversion on an ExchangeUnit 
    public static double Convert(ExchangeUnit exchange)
    {
        foreach (ConversionInfo info in conversions)
        {
            if (info.currencyIn.Equals(exchange.CurrencyIn) &&
                info.currencyOut.Equals(exchange.CurrencyOut))
            {
                return exchange.Amount * info.conversionFactor;
            }
        }

        return -1;
    }
}

// Class to encapsulate a Conversion Information between currencies
internal class ConversionInfo
{
    internal string currencyIn;
    internal string currencyOut;
    internal double conversionFactor;

    internal ConversionInfo(string currencyIn, string currencyOut, double conversionFactor)
    {
        this.currencyIn = currencyIn;
        this.currencyOut = currencyOut;
        this.conversionFactor = conversionFactor;
    }
}

// Class to encapsulate a Exchange request between two currencies
public class ExchangeUnit
{
    double amount;
    string currencyIn;
    string currencyOut;

    ManualResetEvent signal;
    double exAmount;

    public ExchangeUnit(double amount, 
        string currencyIn, 
        string currencyOut,
        ManualResetEvent signal)
    {
        this.amount = amount;
        this.currencyIn = currencyIn;
        this.currencyOut = currencyOut;

        this.signal = signal;
    }

    public double Amount
    {
        get { return amount; }
    }

    public string CurrencyIn
    {
        get { return currencyIn; }
    }

    public string CurrencyOut
    {
        get { return currencyOut; }
    }

    public double ExAmount
    {
        get { return exAmount; }
    }

    // Wrapper method for use with thread pool
    public void ThreadPoolCallback(Object threadContext)
    {
        exAmount = MulticurrencyExchanger.Convert(threadContext as ExchangeUnit);
        signal.Set();
    }
}

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

class Program
{
    static void Main(string[] args)
    {           

        //Invoke the MulticurrencyExchanger Init() method on a separate thread 
        MulticurrencyExchanger exchanger = new MulticurrencyExchanger();
        Thread thread = new Thread(new ThreadStart(exchanger.Init));
        thread.Start();

        ExchangeUnit[] exchanges = new ExchangeUnit[3];
        // One event is used for each ExchangeUnit object
        ManualResetEvent[] signalEvents = new ManualResetEvent[3];
        for (int i = 0; i < 3; i++)
        {
            signalEvents[i] = new ManualResetEvent(false);                
        }

        exchanges[0] = new ExchangeUnit(100.00, "USD", "RS", signalEvents[0]);
        exchanges[1] = new ExchangeUnit(100.00, "EURO", "RS", signalEvents[1]);
        exchanges[2] = new ExchangeUnit(100.00, "GBP", "RS", signalEvents[2]);

        // Calculate exchanges for 10 times so that fluctuating exchange rates reflect
        for (int j = 0; j < 10; j++)
        {
            // Launch threads for an ExchangeUnit using ThreadPool
            for (int i = 0; i < 3; i++)
            {
                ThreadPool.QueueUserWorkItem(exchanges[i].ThreadPoolCallback, exchanges[i]);
            }

            // Wait for all threads in pool
            WaitHandle.WaitAll(signalEvents);

            // Display the results
            for (int i = 0; i < 3; i++)
            {
                Console.WriteLine("{0} {1}={2} {3}",
                    exchanges[i].CurrencyIn, exchanges[i].Amount, exchanges[i].CurrencyOut, exchanges[i].ExAmount);
            }

            // Sleep for 1 sec before going to next iteration
            Thread.Sleep(1000);
        }

        // Stop the thread for the MulticurrencyExchanger object
        thread.Abort();

        Console.ReadLine();
    }
}