public CallbackInfo(Action<RawBusMessage, Exception> callback, Type replyType, ManualResetEvent ev, RegisteredWaitHandle handle)
 {
     _callback = callback;
     _replyType = replyType;
     _ev = ev;
     _handle = handle;
 }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="nextCheckSeconds">check again after X seconds</param>
        /// <param name="containerName">what container to sync</param>
        public static void CheckAsync(int nextCheckSeconds, string containerName, string rootPath)
        {
            lock (typeof(QuickDeployService)) {
                
                // clear existing handle if already exists
                if (RegisteredWaitHandle != null)
                    RegisteredWaitHandle.Unregister(null);

                var waitHandle = new AutoResetEvent(false);
                RegisteredWaitHandle = ThreadPool.RegisterWaitForSingleObject(
                    waitHandle,
                    // Method to execute
                    (state, timeout) => {
                        WhenTimeComes(containerName, rootPath);
                    },
                    // optional state object to pass to the method
                    null,
                    // Execute the method after 5 seconds
                    TimeSpan.FromSeconds(nextCheckSeconds),
                    // Set this to false to execute it repeatedly every 5 seconds
                    false
                );
            }
        }

		public void SetTimer(int MillisecondTimeout, TimeElapsedHandler CB)
		{
			lock(TimeoutList)
			{
				long Ticks = DateTime.Now.AddMilliseconds(MillisecondTimeout).Ticks;
				while(TimeoutList.ContainsKey(Ticks)==true)
				{
					++Ticks;
				}

				TimeoutList.Add(Ticks,CB);
				if(TimeoutList.Count==1)
				{
					// First Entry
					mre.Reset();
					handle = ThreadPool.RegisterWaitForSingleObject(
						mre,
						WOTcb,
						null,
						MillisecondTimeout,
						true);
				}
				else
				{
					mre.Set();
				}
			}
		}

        public HeartbeatSender(TimeSpan period, RestTarget heartbeatRest)
        {
            _period = period;
            _heartbeatRest = heartbeatRest;

            _registeredWaitHandle = ThreadPool.RegisterWaitForSingleObject(_disposeEvent, SendHeartBeats, null, _period, false);
        }

        public bool unregister()
        {
            ManualResetEvent callbackThreadComplete = new ManualResetEvent(false);
            int timeToWait = 5000; //milliseconds
            System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
            sw.Start();
            if (this.sessionRegisteredWait != null)
            {
                if (this.sessionRegisteredWait.Unregister(callbackThreadComplete))
                {
                    Console.WriteLine("waiting on succesful unregister");
                    callbackThreadComplete.WaitOne(timeToWait);
                }
            }
            this.sessionRegisteredWait = null;

            long elapsed = sw.ElapsedMilliseconds;
            Console.WriteLine("Elapsed: {0} millisec", elapsed);
            if (elapsed >= timeToWait)
            {
                Console.WriteLine("Error. Callback was not signaled");
                return false;
            }
            else
            {
                Console.WriteLine("Success");
                return true;
            }
            

            

        }

        /// <summary>
        /// create a buffer recorder for a stream
        /// </summary>
        /// <param name="number">ordinal for diagnostics</param>
        /// <param name="streamID">the stream I'm for</param>
        public BufferRecorder( int number, int streamID )
        {
            isAvailable = true;

            this.number =  number;

            indices = new Index[Constants.IndexCapacity];
            currentIndex = 0;

            buffer = new byte[Constants.BufferSize];
            this.streamID = streamID;

            // setup the db writer thread
            canSave = new AutoResetEvent(false);
            // The BufferTimeout feature is "turned off" so that the buffer won't automatically write to disk sporadically.
            //  This is a nice safety feature we should try to turn back on.  It was turned off because it was saving data
            //  and causing frames to be written out of order in the DB.
            waitHandle = ThreadPool.RegisterWaitForSingleObject( canSave,
                new WaitOrTimerCallback(InitiateSave),
                this,
                Constants.BufferTimeout,
                false);

            Thread.Sleep(50); // Allows for the Registration to occur & get setup
            // Without the Sleep, if we walk into a massive session with lots of data moving, we get slammed & can't keep up.
        }

        /// <summary>
        /// set ourselves up, we are pretty dumb so need to be told who we're sending for
        /// and where to get our data from, and when to start sending..
        /// </summary>
        /// <remarks>
        /// It seems that we don't use maxFrameSize any more.  hmm.  Remove it?
        /// </remarks>
        public BufferPlayer(int streamID, int maxFrameSize, int maxFrameCount, int maxBufferSize)
        {
            Debug.Assert( maxBufferSize >= maxFrameSize ); // just for kicks...

            buffer = new BufferChunk( maxBufferSize );
            indices = new Index[maxFrameCount+1]; // Pri3: why is this "+1" here? (DO NOT REMOVE YET)

            this.populating = false;
            this.streamOutOfData = false;
            this.streamID = streamID;

            this.currentIndex = 0;
            this.indexCount = 0;
            this.startingTick = 0;

            canPopulate = new AutoResetEvent(false);

            // pool a thread to re-populate ourselves
            waitHandle = ThreadPool.RegisterWaitForSingleObject(
                canPopulate,
                new WaitOrTimerCallback( InitiatePopulation ),
                this,
                -1, // never timeout to perform a population
                false );
        }

 private void BeginRunOnTimer(object state, bool isTimeout)
 {
     //Wait for this race condition to satisfy
     while (m_registeredHandle == null)
         ;
     m_registeredHandle.Unregister(null);
     m_registeredHandle = null;
     OnRunning();
 }

        private volatile int flushIsRunning = 0; // 0 = false, 1 = true

        #endregion Fields

        #region Constructors

        public QueueLogWriter()
        {
            File.Delete(aof);

            fileStream = new FileStream(aof, FileMode.OpenOrCreate, FileAccess.Write);

            flushSignalWaitHandle
                = ThreadPool.RegisterWaitForSingleObject(flushSignal, (state, timedOut) => Flush(), null, -1, false);
            flushSignal.Set(); // signal to start pump right away
        }

 public EventsQueue(Boolean bufferedOutput, Int32 autoFlushPeriod, 
     Action<IEnumerable<EventRecord>> flushAction)
 {
     this.bufferedOutput = bufferedOutput;
     this.flushAction = flushAction;
     this.syncObject = new Object();
     this.eventsList = new List<EventRecord>();
     this.flushEvent = new AutoResetEvent(false);
     this.registeredWaitHandle = ThreadPool.RegisterWaitForSingleObject(
         this.flushEvent, FlushEventSignaledCallback, null, autoFlushPeriod * 1000, false);
 }

        public void RegisterTimeout(TimeSpan interval, Action callback)
        {
            lock (m_syncRoot)
            {
                if (m_callback != null)
                    throw new Exception("Duplicate calls are not permitted");

                m_callback = callback;
                m_resetEvent = new ManualResetEvent(false);
                m_registeredHandle = ThreadPool.RegisterWaitForSingleObject(m_resetEvent, BeginRun, null, interval, true);
            }
        }

 private static void InitializeConnectionTimeoutHandler()
 {
     _socketTimeoutDelegate = new WaitOrTimerCallback(TimeoutConnections);
     _socketTimeoutWaitHandle = new AutoResetEvent(false);
     _registeredWaitHandle = 
         ThreadPool.UnsafeRegisterWaitForSingleObject(
             _socketTimeoutWaitHandle, 
             _socketTimeoutDelegate, 
             "IpcConnectionTimeout", 
             _socketTimeoutPollTime, 
             true); // execute only once
 } // InitializeSocketTimeoutHandler

 public unsafe void CancelAsyncOperation()
 {
     this.rootedHolder.ThisHolder = null;
     if (this.registration != null)
     {
         this.registration.Unregister(null);
         this.registration = null;
     }
     this.bufferPtr = null;
     this.bufferHolder[0] = dummyBuffer;
     this.pendingCallback = null;
 }

 private static void TimeoutSockets(object state, bool wasSignalled)
 {
     DateTime utcNow = DateTime.UtcNow;
     lock (_connections)
     {
         foreach (DictionaryEntry entry in _connections)
         {
             ((RemoteConnection) entry.Value).TimeoutSockets(utcNow);
         }
     }
     _registeredWaitHandle.Unregister(null);
     _registeredWaitHandle = ThreadPool.UnsafeRegisterWaitForSingleObject(_socketTimeoutWaitHandle, _socketTimeoutDelegate, "TcpChannelSocketTimeout", _socketTimeoutPollTime, true);
 }

 static Log() {
   _useDiagnostic = System.Diagnostics.Debugger.IsAttached;
   try { int window_height = Console.WindowHeight; _useConsole = true; }
   catch { _useConsole = false; }
   if(!Directory.Exists("../log")) {
     Directory.CreateDirectory("../log");
   }
   useFile = true;
   _lfMask = "../log/{0}_" + Path.GetFileNameWithoutExtension(System.Reflection.Assembly.GetEntryAssembly().Location) + ".log";
   _records = new System.Collections.Concurrent.ConcurrentQueue<LogRecord>();
   _kickEv = new AutoResetEvent(false);
   _wh = ThreadPool.RegisterWaitForSingleObject(_kickEv, Process, null, -1, false);
 }

 public void Cancel()
 {
     lock (m_syncRoot)
     {
         if (m_registeredHandle != null)
         {
             m_registeredHandle.Unregister(null);
             m_resetEvent.Dispose();
             m_resetEvent = null;
             m_registeredHandle = null;
             m_callback = null;
         }
     }
 }

 private void BeginRun(object state, bool isTimeout)
 {
     lock (m_syncRoot)
     {
         if (m_registeredHandle == null)
             return;
         m_registeredHandle.Unregister(null);
         m_resetEvent.Dispose();
         m_callback();
         m_resetEvent = null;
         m_registeredHandle = null;
         m_callback = null;
     }
 }

        public void register()
        {


            this.sessionNotification = new ManualResetEvent(false);
      
            this.sessionRegisteredWait = ThreadPool.RegisterWaitForSingleObject(
                                                            this.sessionNotification,
                                                            ServiceCallbackOnPositionAvailable,
                                                            this,   /* object state */
                                                            -1,     /* INFINITE */
                                                            true    /* ExecuteOnlyOnce */);


        }

        private void Begin(Func<AsyncCallback, object, IAsyncResult> beginMethod, AsyncCallback callback, object state, TimeSpan timeout)
        {
            this.asyncResult = beginMethod(callback, state);

#if WINDOWS_PHONE
            WaitHandle asyncWaitHandle = this.fakeEvent;
#else
            WaitHandle asyncWaitHandle = this.asyncResult.AsyncWaitHandle;
#endif

            this.waitHandle = ThreadPool.RegisterWaitForSingleObject(asyncWaitHandle, this.WaitCallback, state, timeout, true);
            if (this.disposed)
            {
                this.UnregisterWaitHandle();
            }
        }

        public ConnectionCache(int keepAlive, ConnectionFactory connectionFactory)
        {
            // parameters validation
            if (connectionFactory == null)
                throw new ArgumentNullException("connectionFactory");
            if (keepAlive < 1)
                throw new ArgumentOutOfRangeException("keepAlive");

            _connectionFactory = connectionFactory;
            _keepAlive = TimeSpan.FromSeconds(keepAlive);

            // Schedule timeout method
            _timeoutDelegate = OnTimerElapsed;
            _timeoutWaitHandle = new AutoResetEvent(false);
            _registeredTimeoutWaitHandle = ThreadPool.RegisterWaitForSingleObject(
                _timeoutWaitHandle, _timeoutDelegate, null, _keepAlive, true);
        }