Question

Its a follow up of this question.

https://stackoverflow.com/questions/12260170/how-to-make-a-threadpool-to-be-nonblocking

I have achieved it using interface. I have made it nonblocking using Action/deleages & using interfaces.. Is there any other way available in .net that I can make the below piece of code nonblocking??? Interface implementation is below. At any point of time I should have only three functions Main, FuncA & FuncB

if some one could kindly help. it will be really appreciated. Thank you.

using System;
using System.Threading;

namespace ConsoleApplication2
{
    public interface IOperation
    {
        void CallBack(int i);
    }

    public class FuncBCalculation
    {
        public int N { get { return _n; } }
        private int _n;

        public int MyValue { get; set; }
        public FuncBCalculation(int n)
        {
            _n = n;
        }

        // Wrapper method for use with thread pool.
        public void FuncB(object context)
        {
            IOperation FuncBcallback = (IOperation)context;
            Thread.Sleep(5);
            MyValue = _n + 2;
            FuncBcallback.CallBack(MyValue);
        }
    }

    public class ActualClass : IOperation
    {
        int Finalvalue = 0;
        public static IOperation MainThreadCallBack { get; set; }

        public void FuncA(int input, int i, IOperation callback)
        {
            input += 1;
            var f = new FuncBCalculation(input);
            MainThreadCallBack = callback;
            IOperation op = new ActualClass();
            ThreadPool.QueueUserWorkItem(f.FuncB, op);

        }

        //Method for callback operation
        public void CallBack(int i)
        {
            Finalvalue = i + 3;
            if (MainThreadCallBack != null)
                MainThreadCallBack.CallBack(Finalvalue);
        }
    }


    public class ThreadPoolExample : IOperation
    {
        static void Main()
        {
            ActualClass actualCall;
            const int TotalLoopCount = 1000;
            int input = 11;
            Console.WriteLine("launching {0} tasks...", TotalLoopCount);
            for (int i = 0; i < TotalLoopCount; i++)
            {
                IOperation op = new ThreadPoolExample();
                actualCall = new ActualClass();
                actualCall.FuncA(input, i, op);
            }
            Console.ReadKey();
        }

        //Method for callback operation for the main thread
        public void CallBack(int i)
        {
            Console.WriteLine("The final Result is {0}", i);
        }

    }

}

Answer 1

public class State
{
    public int input { get; set; }
    public int result { get; set; }
    //public static int ThreadCount { get; set; }
    public bool FuncBSignalON { get; set; }
    //public static bool FuncAThreadON { get; set; }
   //public int TotalLoopCount { get; set; }
    //public int ThreadID { get; set; }
}


public class MainClass
{
    public static void FuncB(Object stateObject)
    {
        State state = stateObject as State;
        state.input += 2;
        state.FuncBSignalON = true;
        ThreadPool.QueueUserWorkItem(new WaitCallback(FuncA), state);
    }

    public static void FuncA(Object stateObject)
    {
        State state = (State)stateObject;
        if (!state.FuncBSignalON)
        {
            state.input += 1;
            ThreadPool.QueueUserWorkItem(new WaitCallback(FuncB), state);
        }
        else
        {
            state.result = state.input + 3;
            //FinalResult.Add(state.result);
            string[] stateResult = new string[1];
            stateResult[0] = state.result.ToString();
            //State.ThreadCount--;
            Main(stateResult);
        }
    }

    static void Main(string[] args)
    {
        if (args.Count() == 0)
        {
            int TotalLoopCount =1000; 
            for (int i = 0; i < TotalLoopCount; i++)
            {
                State FuncAstate = new State();
                FuncAstate.input = 11;
                //FuncAstate.TotalLoopCount = TotalLoopCount;
                //State.ThreadCount++;
                ThreadPool.QueueUserWorkItem(new WaitCallback(FuncA), FuncAstate);
            }
        }
        else
        {
          Console.WriteLine(args[0]);
        }
        Console.ReadKey();
    }

}

Got it at last.