File: MS\Internal\AutomationProxies\QueueProcessor.cs
Web Access
Project: src\src\Microsoft.DotNet.Wpf\src\UIAutomation\UIAutomationClientSideProviders\UIAutomationClientSideProviders.csproj (UIAutomationClientSideProviders)
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
 
// Description:
//      Class to create a queue on the client context.  
//      WinEventHooks must be processed in the same thread that created them.
//      A seperate thread is created by the win32 proxy to manage the hooks.
//              
 
using System.Windows.Automation;
using System.Windows.Automation.Provider;
using System;
using System.Threading;
using System.Collections;
using System.Diagnostics;
using System.Runtime.InteropServices;
using MS.Win32;
using Microsoft.Win32.SafeHandles;
 
namespace MS.Internal.AutomationProxies
{
    class QueueProcessor
    {
        // ------------------------------------------------------
        //
        // Constructors
        //
        // ------------------------------------------------------
 
        #region Constructors
 
        // Usage is to create QueueProcessor object and call StartOnThread
        internal QueueProcessor(int initCapacity)
        {
            _ev = new AutoResetEvent(false);
            _q = Queue.Synchronized(new Queue(initCapacity));
        }
 
        // Default constructor.
        // Create a Queue of jobs with 4 elements
        internal QueueProcessor() : this(4) 
        {
        }
 
        #endregion
         
        // ------------------------------------------------------
        //
        // Internal Methods
        //
        // ------------------------------------------------------
 
        #region Internal Methods
 
        // Create and start a background thread for this worker window to 
        // run on (background threads will exit if the main and foreground 
        // threads exit)
        internal void StartOnThread ()
        {
            ThreadStart threadStart = new ThreadStart(WaitForWork);
            Thread thread = new Thread(threadStart);
            thread.IsBackground = true;
            thread.Start();
        }
 
        // Post a work item and wait for it to be processed.
        // The processing of the item is done on the client thread
        internal bool PostSyncWorkItem (QueueItem workItem)
        {
            QueueItem.SyncQueueItem syncItem = new QueueItem.SyncQueueItem (workItem);
 
            // save the data
            _q.Enqueue (syncItem);
 
            // Start the processing on a different thread
            _ev.Set ();
 
            // Wait for the processing to be completed
            return syncItem._ev.WaitOne (2000, false);
        }
 
        #endregion
 
        // ------------------------------------------------------
        //
        // Private Methods
        //
        // ------------------------------------------------------
    
        #region Private Methods
 
        // Infinite loop. Wait for queue items to be processed.
        private void WaitForWork()
        {
            SafeWaitHandle handle = _ev.SafeWaitHandle;
            NativeMethods.MSG msg = new NativeMethods.MSG();
 
            while (true)
            {
                try
                {
                    // pump any messages
                    while (UnsafeNativeMethods.PeekMessage (ref msg, IntPtr.Zero, 0, 0, NativeMethods.PM_REMOVE))
                    {
                        if (msg.message == NativeMethods.WM_QUIT)
                        {
                            break;
                        }
                        Misc.DispatchMessage(ref msg);
                    }
 
                    // do any work items in the queue
                    // It's possible items could be enqueued between when we check for the count
                    // and dequeue but the event is set then and we'll come back into DrainQueue.
                    // (note: don't use a for loop here because as the counter is incremented
                    // Count is decremented and we'll only process half the queue)
                    while (_q.Count > 0)
                    {
                        // pull an item off the queue, process, then clear it
                        QueueItem item = (QueueItem) _q.Dequeue ();
 
                        item.Process ();
                    }
 
                    int result = Misc.MsgWaitForMultipleObjects(handle, false, NativeMethods.INFINITE, NativeMethods.QS_ALLINPUT);
                    if (result == NativeMethods.WAIT_FAILED || result == NativeMethods.WAIT_TIMEOUT)
                    {
                        Debug.Assert(false, "MsgWaitForMultipleObjects failed while WaitForWork");
                        break;
                    }
                }
                catch( Exception e )
                {
                    if (Misc.IsCriticalException(e))
                        throw;
 
                    // Might happen when if the hwnd goes away between the peek and the dispatch
                }
            }
        }
 
        #endregion
 
        // ------------------------------------------------------
        //
        // Private Fields
        //
        // ------------------------------------------------------
    
        #region Private Fields
 
        // A synchronized queue.
        private Queue _q;
 
        // Notifies when new queue items show up.
        private AutoResetEvent _ev;
 
        #endregion
    }
 
    // ------------------------------------------------------
    //
    //  QueueItem abstract class
    //
    //------------------------------------------------------
 
    #region QueueItem Abstract Class
 
    // Abstract class for worker objects queued to the QueueProcessor class
    abstract class QueueItem
    {
        // ------------------------------------------------------
        //
        // Internal Methods
        //
        // ------------------------------------------------------
 
        #region Internal Methods
 
        // Process an item in a different thread
        internal abstract void Process ();
 
        #endregion
 
        // ------------------------------------------------------
        //
        // SyncQueueItem Private Class
        //
        // ------------------------------------------------------
 
        #region SyncQueueItem
 
        // Not many of these will be created at a time so having the
        // event in the class is OK and easier than having just one
        // that manages any sync method call.
        internal class SyncQueueItem : QueueItem
        {
            // ------------------------------------------------------
            //
            // Constructors
            //
            // ------------------------------------------------------
 
            #region Constructors
 
            // Queue an item to be processed in a different thread.
            internal SyncQueueItem (QueueItem qItem)
            {
                _ev = new AutoResetEvent (false);
                _qItem = qItem;
            }
 
            #endregion
 
            // ------------------------------------------------------
            //
            // Internal Methods
            //
            // ------------------------------------------------------
 
            #region Internal Methods
 
            // Process an item from the queue
            internal override void Process ()
            {
                // Calls the overloaded version of Process
                _qItem.Process ();
                _ev.Set ();
            }
 
            #endregion
 
            // ------------------------------------------------------
            //
            // Internal Fields
            //
            // ------------------------------------------------------
 
            #region Internal Fields
 
            internal AutoResetEvent _ev;
 
            #endregion
 
            // ------------------------------------------------------
            //
            // Private Fields
            //
            // ------------------------------------------------------
 
            #region Private Fields
 
            private QueueItem _qItem;
 
            #endregion
        }
 
        #endregion
 
        // ------------------------------------------------------
        //
        // WinEventItem Private Class
        //
        // ------------------------------------------------------
 
        #region WinEventItem
 
        // Worker class used to handle WinEvents
        internal class WinEventItem : QueueItem
        {
            // ------------------------------------------------------
            //
            // Constructors
            //
            // ------------------------------------------------------
 
            #region Constructors
 
            internal WinEventItem (ref WinEventTracker.EventHookParams hp, WinEventTracker.StartStopDelegate ssd)
            {
                _hp = hp;
                _ssd = ssd;
            }
 
            #endregion
 
            // ------------------------------------------------------
            //
            // Internal Methods
            //
            // ------------------------------------------------------
 
            #region Internal Methods
 
            internal override void Process ()
            {
                _ssd (ref _hp);
            }
 
            #endregion
 
            // ------------------------------------------------------
            //
            // Private Methods
            //
            // ------------------------------------------------------
 
            #region Private Field
 
            // WinEvent Hook parameters
            private WinEventTracker.EventHookParams _hp;
 
            // Delegate to Start/Stop the WinEvent thread on the client context
            private WinEventTracker.StartStopDelegate _ssd;
 
            #endregion
        }
 
        #endregion
 
 
        // ------------------------------------------------------
        //
        // MSAAWinEventItem Private Class
        //
        // ------------------------------------------------------
 
        #region MSAAWinEventItem
 
        // Worker class used to handle WinEvents
        internal class MSAAWinEventItem : QueueItem
        {
            // ------------------------------------------------------
            //
            // Constructors
            //
            // ------------------------------------------------------
 
            #region Constructors
 
            internal MSAAWinEventItem(MSAAWinEventWrap.StartStopDelegate ssd)
            {
                _ssd = ssd;
            }
 
            #endregion
 
            // ------------------------------------------------------
            //
            // Internal Methods
            //
            // ------------------------------------------------------
 
            #region Internal Methods
 
            internal override void Process()
            {
                _ssd();
            }
 
            #endregion
 
            // ------------------------------------------------------
            //
            // Private Methods
            //
            // ------------------------------------------------------
 
            #region Private Field
 
            // Delegate to Start/Stop the WinEvent thread on the client context
            private MSAAWinEventWrap.StartStopDelegate _ssd;
 
            #endregion
        }
 
        #endregion
    }
 
    #endregion
}