.Net threadpool synchronizing using AutoResetEvent

Hi, 

Following is the code that I use, so that Main thread wait for Threadpool threads to execute, I use AutoResetEvent, but I am really surprised that I am way off the mark, as the code doesn't behave as expected.

- I have two concentric for loops, where threadpool is in the inner loop and it is expected that for each iteration of Outer loop, all the inner loop values should be processed. Main thread is made to wait using AutoResetEvent WaitOne call just outside inner loop, a static variable which is reset in every iteration of outerloop to max value of inner loop and is decremented using Interlock in the method call on Threadpool thread is used to call the Set for the AutoResetEvent. However, even when I expect the static variable to show value 0 after every inner loop, it doesn't. What is the issue in my code and what are better options for me to accomplish the task.

thanks,

Mrinal

// Code ::

    using System;
    using System.Threading;

    namespace TestThreads
    {
    class Program
    {
        private static int threadingCounter = 0;
        private static readonly object lockThreads = new Object();
        private AutoResetEvent areSync = new AutoResetEvent(true);
         
        /// <summary>
        /// 
        /// </summary>
        /// <param name="args"></param>
        static void Main(string[] args)
        {
            Program myProgram = new Program();

            try
            {
                try
                {   
                    for (int outer = 0; outer < 1000; outer++)
                    {
                        threadingCounter = 500;
                        try
                        {
                            for (int inner = 0; inner < 500; inner++)
                            {
              ThreadPool.QueueUserWorkItem(new WaitCallback(myProgram.ThreadCall), inner);
                            }
                        }
                        catch (Exception ex)
                        {
                            Console.WriteLine("Exception :: " + ex.Message);
                        }
                        finally
                        {                            
                            myProgram.areSync.WaitOne();
                        }

                        if(threadingCounter != 0)
                            Console.WriteLine("In Loop1, Thread Counter :: " + threadingCounter);
                    }
                }
                catch (Exception ex)
                {
                    Console.WriteLine("Exception :: " + ex.Message);
                }                
            }
            catch(Exception ex)
            {
                Console.WriteLine("Exception :: " + ex.Message);
            }
            finally
            {
                threadingCounter = 0;

                if (myProgram.areSync != null)
                {
                    myProgram.areSync.Dispose();
                    myProgram.areSync = null;
                }

            }
        }

        public void ThreadCall(object state)
        {
            try
            {

                int inner = (int)state;
                Thread.Sleep(1);
            }
            catch (Exception ex)
            {
                Console.WriteLine("Exception :: " + ex.Message);
            }
            finally
            {
                Interlocked.Decrement(ref threadingCounter);
                if (threadingCounter <= 0)
                    areSync.Set();
            }
                
        }        
     }   
     }