UIAutomation踩坑

internal static void AddListener(AutomationElement rawEl, Delegate eventCallback, EventListener l)
{
    lock (_classLock)
    {
        // If we are adding a listener then a proxy could be created as a result of an event so make sure they are loaded
        ProxyManager.LoadDefaultProxies();

        if (_listeners == null)
        {
            // enough space for 16 AddXxxListeners (100 bytes)
            _listeners = new ArrayList(16);
        }

        // Start the callback queue that gets us off the server's
        // UI thread when events arrive cross-proc
        CheckStartCallbackQueueing();

        //
        // The framework handles some events on behalf of providers; do those here
        //

        // If listening for BoundingRectangleProperty then may need to start listening on the
        // client-side for LocationChange WinEvent (only use *one* BoundingRectTracker instance).
        if (_winEventTrackers[(int)Tracker.BoundingRect] == null && HasProperty(AutomationElement.BoundingRectangleProperty, l.Properties))
        {
            //
            AddWinEventListener(Tracker.BoundingRect, new BoundingRectTracker());
        }

        // Start listening for menu event in order to raise MenuOpened/Closed events.
        if ( _winEventTrackers [(int)Tracker.MenuOpenedOrClosed] == null && (l.EventId == AutomationElement.MenuOpenedEvent || l.EventId == AutomationElement.MenuClosedEvent) )
        {
            AddWinEventListener( Tracker.MenuOpenedOrClosed, new MenuTracker( new MenuHandler( OnMenuEvent ) ) );
        }

        // Begin watching for hwnd open/close/show/hide so can advise of what events are being listened for.
        // Only advise UI contexts of events being added if the event might be raised by a provider.
        // TopLevelWindow event is raised by UI Automation framework so no need to track new UI.
        // 
        if (_winEventTrackers[(int)Tracker.WindowShowOrOpen] == null )
        {
            AddWinEventListener( Tracker.WindowShowOrOpen, new WindowShowOrOpenTracker( new WindowShowOrOpenHandler( OnWindowShowOrOpen ) ) );
            AddWinEventListener( Tracker.WindowHideOrClose, new WindowHideOrCloseTracker( new WindowHideOrCloseHandler( OnWindowHideOrClose ) ) );
        }

        // If listening for WindowInteractionStateProperty then may need to start listening on the
        // client-side for ObjectStateChange WinEvent.
        if (_winEventTrackers[(int)Tracker.WindowInteractionState] == null && HasProperty(WindowPattern.WindowInteractionStateProperty, l.Properties))
        {
            AddWinEventListener(Tracker.WindowInteractionState, new WindowInteractionStateTracker());
        }

        // If listening for WindowVisualStateProperty then may need to start listening on the
        // client-side for ObjectLocationChange WinEvent.
        if (_winEventTrackers[(int)Tracker.WindowVisualState] == null && HasProperty(WindowPattern.WindowVisualStateProperty, l.Properties))
        {
            AddWinEventListener(Tracker.WindowVisualState, new WindowVisualStateTracker());
        }

        // Wrap and store this record on the client...
        EventListenerClientSide ec = new EventListenerClientSide(rawEl, eventCallback, l);
        _listeners.Add(ec);

        // Only advise UI contexts of events being added if the event might be raised by
        // a provider.  TopLevelWindow event is raised by UI Automation framework.
        if (ShouldAdviseProviders( l.EventId ))
        {
            // .. then let the server know about this listener
            ec.EventHandle = UiaCoreApi.UiaAddEvent(rawEl.RawNode, l.EventId.Id, ec.CallbackDelegate, l.TreeScope, PropertyArrayToIntArray(l.Properties), l.CacheRequest);
        }
    }
}

private static void CheckStartCallbackQueueing()
{
    if (!_isBkgrdThreadRunning)
    {
        _isBkgrdThreadRunning = true;
        _callbackQueue = new QueueProcessor();
        _callbackQueue.StartOnThread();
    }
}

internal void StartOnThread()
{
    _quitting = false;

    // create and start a background thread for this worker window to run on
    // (background threads will exit if the main and foreground threads exit)
    ThreadStart threadStart = new ThreadStart(WaitForWork);
    _thread = new Thread(threadStart);
    _thread.IsBackground = true;
    _thread.Start();
}

internal void PostQuit()
{
    _quitting = true;
    _ev.Set();
}

private static void CheckStopCallbackQueueing()
{
    // anything to stop?
    if (!_isBkgrdThreadRunning)
        return;

    // if there are listeners then can't stop
    if (_listeners != null)
        return;

    // Are any WinEvents currently being tracked for this client?
    foreach (WinEventWrap eventWrapper in _winEventTrackers)
    {
        if (eventWrapper != null)
        {
            return;
        }
    }

    // OK to stop the queue now
    _isBkgrdThreadRunning = false;
    _callbackQueue.PostQuit();
    // Intentionally not setting _callbackQueue null here; don't want to mess with it from this thread.
}

private static void RemoveWinEventListener(Tracker idx, Delegate eventCallback)
{
    WinEventWrap eventWrapper = _winEventTrackers[(int)idx];
    if (eventWrapper == null)
        return;

    bool fRemovedLastListener = eventWrapper.RemoveCallback(eventCallback);
    if (fRemovedLastListener)
    {
        _callbackQueue.PostSyncWorkItem(new WinEventQueueItem(eventWrapper, WinEventQueueItem.StopListening));
        _winEventTrackers[(int)idx] = null;

        CheckStopCallbackQueueing();
    }
}

internal static void RemoveListener( AutomationEvent eventId, AutomationElement el, Delegate eventCallback )
{
    lock( _classLock )
    {
        if( _listeners != null )
        {
            bool boundingRectListeners = false; // if not removing BoundingRect listeners no need to do check below
            bool menuListeners = false; // if not removing MenuOpenedOrClosed listeners no need to do check below
            bool windowInteracationListeners = false; // if not removing WindowsIntercation listeners no need to do check below
            bool windowVisualListeners = false; // if not removing WindowsVisual listeners no need to do check below

            for (int i = _listeners.Count - 1; i >= 0; i--)
            {
                EventListenerClientSide ec = (EventListenerClientSide)_listeners[i];
                if( ec.IsListeningFor( eventId, el, eventCallback ) )
                {
                    EventListener l = ec.EventListener;

                    // Only advise UI contexts of events being removed if the event might be raised by
                    // a provider.  TopLevelWindow event is raised by UI Automation framework.
                    if ( ShouldAdviseProviders(eventId) )
                    {
                        // Notify the server-side that this event is no longer interesting
                        try
                        {
                            ec.EventHandle.Dispose(); // Calls UiaCoreApi.UiaRemoveEvent
                        }
// PRESHARP: Warning - Catch statements should not have empty bodies
#pragma warning disable 6502
                        catch (ElementNotAvailableException)
                        {
                            // the element is gone already; continue on and remove the listener
                        }
#pragma warning restore 6502
                        finally
                        {
                            ec.Dispose();
                        }
                    }

                    // before removing, check if this delegate was listening for the below events
                    // and see if we can stop clientside WinEvent trackers.
                    if (HasProperty(AutomationElement.BoundingRectangleProperty, l.Properties))
                    {
                        boundingRectListeners = true;
                    }

                    if( eventId == AutomationElement.MenuOpenedEvent || eventId == AutomationElement.MenuClosedEvent )
                    {
                        menuListeners = true;
                    }

                    if (HasProperty(WindowPattern.WindowInteractionStateProperty, l.Properties))
                    {
                        windowInteracationListeners = true;
                    }

                    if (HasProperty(WindowPattern.WindowVisualStateProperty, l.Properties))
                    {
                        windowVisualListeners = true;
                    }

                    // delete this one
                    _listeners.RemoveAt( i );
                }
            }

            // Check listeners bools to see if clientside listeners can be removed
            if (boundingRectListeners)
            {
                RemovePropertyTracker(AutomationElement.BoundingRectangleProperty, Tracker.BoundingRect);
            }

            if (menuListeners)
            {
                RemoveMenuListeners();
            }

            if (windowInteracationListeners)
            {
                RemovePropertyTracker(WindowPattern.WindowInteractionStateProperty, Tracker.WindowInteractionState);
            }

            if (windowVisualListeners)
            {
                RemovePropertyTracker(WindowPattern.WindowVisualStateProperty, Tracker.WindowVisualState);
            }

            // See if we can cleanup completely
            if (_listeners.Count == 0)
            {
                // as long as OnWindowShowOrOpen is static can just use new here and get same object instance
                // (if there's no WindowShowOrOpen listener, this method just returns)
                RemoveWinEventListener(Tracker.WindowShowOrOpen, new WindowShowOrOpenHandler(OnWindowShowOrOpen));
                RemoveWinEventListener( Tracker.WindowHideOrClose, new WindowHideOrCloseHandler( OnWindowHideOrClose ) );

                _listeners = null;
            }
        }
    }
}

internal static void RemoveAllListeners()
{
    lock (_classLock)
    {
        if (_listeners == null)
            return;