Utilizzare la memorizzazione nella cache per l'automazione interfaccia utente

Articolo
08/11/2011

Nota
La presente documentazione è destinata agli sviluppatori di .NET Framework che desiderano utilizzare le classi UI Automation gestite definite nello spazio dei nomi System.Windows.Automation.Per informazioni aggiornate sull'UI Automation, vedere Windows Automation API: Automazione interfaccia utente (la pagina potrebbe essere in inglese).

In questa sezione viene illustrato come implementare la memorizzazione nella cache delle proprietà AutomationElement e dei pattern di controllo.

Attivare una richiesta di cache

Creare un oggetto CacheRequest.
Specificare le proprietà e i modelli da memorizzare nella cache utilizzando Add.
Specificare l'ambito di memorizzazione nella cache impostando la proprietà TreeScope.
Specificare la visualizzazione del sottoalbero impostando la proprietà TreeFilter.
Impostare la proprietà AutomationElementMode su None se si desidera aumentare l'efficienza evitando di recuperare un riferimento completo agli oggetti. In questo modo sarà impossibile recuperare i valori correnti da tali oggetti.
Attivare la richiesta utilizzando Activate all'interno di un blocco using (Using in Microsoft Visual Basic .NET).

Dopo aver ottenuto gli oggetti AutomationElement o aver sottoscritto eventi, disattivare la richiesta utilizzando Pop (se si utilizza Push) oppure eliminando l'oggetto creato da Activate. Utilizzare Activate in un blocco using (Using in Microsoft Visual Basic .NET).

Memorizzare nella cache le proprietà AutomationElement

Mentre un oggetto CacheRequest è attivo, ottenere gli oggetti AutomationElement utilizzando FindFirst o FindAll; in alternativa, ottenere un oggetto AutomationElement come origine di un evento per cui è stata eseguita la registrazione quando l'oggetto CacheRequest era attivo. È anche possibile creare una cache passando un oggetto CacheRequest a GetUpdatedCache o a uno dei metodi TreeWalker.
Utilizzare GetCachedPropertyValue o recuperare una proprietà dalla proprietà Cached di AutomationElement.

Ottenere modelli memorizzati nella cache e le relative proprietà

Mentre un oggetto CacheRequest è attivo, ottenere gli oggetti AutomationElement utilizzando FindFirst o FindAll; in alternativa, ottenere un oggetto AutomationElement come origine di un evento per cui è stata eseguita la registrazione quando l'oggetto CacheRequest era attivo. È anche possibile creare una cache passando un oggetto CacheRequest a GetUpdatedCache o a uno dei metodi TreeWalker.
Utilizzare GetCachedPattern o TryGetCachedPattern per recuperare un modello memorizzato nella cache.
Recuperare i valori della proprietà dalla proprietà Cached del pattern di controllo.

Esempio

Nell'esempio di codice seguente sono illustrati vari aspetti della memorizzazione nella cache, utilizzando Activate per attivare CacheRequest.

    ''' <summary>
    ''' Caches and retrieves properties for a list item by using CacheRequest.Activate.
    ''' </summary>
    ''' <param name="elementList">Element from which to retrieve a child element.</param>
    ''' <remarks>
    ''' This code demonstrates various aspects of caching. It is not intended to be 
    ''' an example of a useful method.
    ''' </remarks>
    Private Sub CachePropertiesByActivate(ByVal elementList As AutomationElement)

        ' Set up the request.
        Dim myCacheRequest As New CacheRequest()
        myCacheRequest.Add(AutomationElement.NameProperty)
        myCacheRequest.Add(AutomationElement.IsEnabledProperty)
        myCacheRequest.Add(SelectionItemPattern.Pattern)
        myCacheRequest.Add(SelectionItemPattern.SelectionContainerProperty)

        Dim elementListItem As AutomationElement

        ' Obtain an element and cache the requested items.
        Using myCacheRequest.Activate()
            Dim myCondition As New PropertyCondition( _
                AutomationElement.IsSelectionItemPatternAvailableProperty, True)
            elementListItem = elementList.FindFirst(TreeScope.Children, myCondition)
        End Using


        ' The CacheRequest is now inactive.
        ' Retrieve the cached property and pattern.
        Dim pattern As SelectionItemPattern
        Dim itemName As String
        Try
            itemName = elementListItem.Cached.Name
            pattern = DirectCast(elementListItem.GetCachedPattern(SelectionItemPattern.Pattern), _
                SelectionItemPattern)
        Catch ex As InvalidOperationException
            Console.WriteLine("Object was not in cache.")
            Return
        End Try
        ' Alternatively, you can use TryGetCachedPattern to retrieve the cached pattern.
        Dim cachedPattern As Object = Nothing
        If True = elementListItem.TryGetCachedPattern(SelectionItemPattern.Pattern, cachedPattern) Then
            pattern = DirectCast(cachedPattern, SelectionItemPattern)
        End If

        ' Specified pattern properties are also in the cache.
        Dim parentList As AutomationElement = pattern.Cached.SelectionContainer

        ' The following line will raise an exception, because the HelpText property was not cached.
        '** String itemHelp = elementListItem.Cached.HelpText; **

        ' Similarly, pattern properties that were not specified in the CacheRequest cannot be 
        ' retrieved from the cache. This would raise an exception.
        '** bool selected = pattern.Cached.IsSelected; **

        ' This is still a valid call, even though the property is in the cache.
        ' Of course, the cached value and the current value are not guaranteed to be the same.
        itemName = elementListItem.Current.Name
    End Sub 'CachePropertiesByActivate

/// <summary>
/// Caches and retrieves properties for a list item by using CacheRequest.Activate.
/// </summary>
/// <param name="elementList">Element from which to retrieve a child element.</param>
/// <remarks>
/// This code demonstrates various aspects of caching. It is not intended to be 
/// an example of a useful method.
/// </remarks>
private void CachePropertiesByActivate(AutomationElement elementList)
{
    AutomationElement elementListItem;

    // Set up the request.
    CacheRequest cacheRequest = new CacheRequest();
    cacheRequest.Add(AutomationElement.NameProperty);
    cacheRequest.Add(AutomationElement.IsEnabledProperty);
    cacheRequest.Add(SelectionItemPattern.Pattern);
    cacheRequest.Add(SelectionItemPattern.SelectionContainerProperty);

    // Obtain an element and cache the requested items.
    using (cacheRequest.Activate())
    {
        Condition cond = new PropertyCondition(AutomationElement.IsSelectionItemPatternAvailableProperty, true);
        elementListItem = elementList.FindFirst(TreeScope.Children, cond);
    }
    // The CacheRequest is now inactive.

    // Retrieve the cached property and pattern.
    SelectionItemPattern pattern;
    String itemName;
    try
    {
        itemName = elementListItem.Cached.Name;
        pattern = elementListItem.GetCachedPattern(SelectionItemPattern.Pattern) as SelectionItemPattern;
    }
    catch (InvalidOperationException)
    {
        Console.WriteLine("Object was not in cache.");
        return;
    }
    // Alternatively, you can use TryGetCachedPattern to retrieve the cached pattern.
    object cachedPattern;
    if (true == elementListItem.TryGetCachedPattern(SelectionItemPattern.Pattern, out cachedPattern))
    {
        pattern = cachedPattern as SelectionItemPattern;
    }

    // Specified pattern properties are also in the cache.
    AutomationElement parentList = pattern.Cached.SelectionContainer;

    // The following line will raise an exception, because the HelpText property was not cached.
    /*** String itemHelp = elementListItem.Cached.HelpText; ***/

    // Similarly, pattern properties that were not specified in the CacheRequest cannot be 
    // retrieved from the cache. This would raise an exception.
    /*** bool selected = pattern.Cached.IsSelected; ***/

    // This is still a valid call, even though the property is in the cache.
    // Of course, the cached value and the current value are not guaranteed to be the same.
    itemName = elementListItem.Current.Name;
}

Nell'esempio di codice seguente sono illustrati vari aspetti della memorizzazione nella cache, utilizzando Push per attivare CacheRequest. Eccetto quando si desidera annidare le richieste di cache, è preferibile utilizzare Activate.

''' <summary>
''' Caches and retrieves properties for a list item by using CacheRequest.Push.
''' </summary>
''' <param name="elementList">Element from which to retrieve a child element.</param>
''' <remarks>
''' This code demonstrates various aspects of caching. It is not intended to be 
''' an example of a useful method.
''' </remarks>
Private Sub CachePropertiesByPush(ByVal elementList As AutomationElement)
    ' Set up the request.
    Dim cacheRequest As New CacheRequest()

    ' Do not get a full reference to the cached objects, only to their cached properties and patterns.
    cacheRequest.AutomationElementMode = AutomationElementMode.None

    ' Cache all elements, regardless of whether they are control or content elements.
    cacheRequest.TreeFilter = Automation.RawViewCondition

    ' Property and pattern to cache.
    cacheRequest.Add(AutomationElement.NameProperty)
    cacheRequest.Add(SelectionItemPattern.Pattern)

    ' Activate the request.
    cacheRequest.Push()

    ' Obtain an element and cache the requested items.
    Dim myCondition As New PropertyCondition(AutomationElement.IsSelectionItemPatternAvailableProperty, _
        True)
    Dim elementListItem As AutomationElement = elementList.FindFirst(TreeScope.Children, myCondition)

    ' At this point, you could call another method that creates a CacheRequest and calls Push/Pop.
    ' While that method was retrieving automation elements, the CacheRequest set in this method 
    ' would not be active. 
    ' Deactivate the request.
    cacheRequest.Pop()

    ' Retrieve the cached property and pattern.
    Dim itemName As String = elementListItem.Cached.Name
    Dim pattern As SelectionItemPattern = _
        DirectCast(elementListItem.GetCachedPattern(SelectionItemPattern.Pattern), SelectionItemPattern)

    ' The following is an alternative way of retrieving the Name property.
    itemName = CStr(elementListItem.GetCachedPropertyValue(AutomationElement.NameProperty))

    ' This is yet another way, which returns AutomationElement.NotSupported if the element does
    ' not supply a value. If the second parameter is false, a default name is returned.
    Dim objName As Object = elementListItem.GetCachedPropertyValue(AutomationElement.NameProperty, True)
    If objName Is AutomationElement.NotSupported Then
        itemName = "Unknown"
    Else
        itemName = CStr(objName)
    End If
    ' The following call raises an exception, because only the cached properties are available, 
    '  as specified by cacheRequest.AutomationElementMode. If AutomationElementMode had its
    '  default value (Full), this call would be valid.
    '** bool enabled = elementListItem.Current.IsEnabled; **

End Sub 'CachePropertiesByPush

/// <summary>
/// Caches and retrieves properties for a list item by using CacheRequest.Push.
/// </summary>
/// <param name="autoElement">Element from which to retrieve a child element.</param>
/// <remarks>
/// This code demonstrates various aspects of caching. It is not intended to be 
/// an example of a useful method.
/// </remarks>
private void CachePropertiesByPush(AutomationElement elementList)
{
    // Set up the request.
    CacheRequest cacheRequest = new CacheRequest();

    // Do not get a full reference to the cached objects, only to their cached properties and patterns.
    cacheRequest.AutomationElementMode = AutomationElementMode.None;

    // Cache all elements, regardless of whether they are control or content elements.
    cacheRequest.TreeFilter = Automation.RawViewCondition;

    // Property and pattern to cache.
    cacheRequest.Add(AutomationElement.NameProperty);
    cacheRequest.Add(SelectionItemPattern.Pattern);

    // Activate the request.
    cacheRequest.Push();

    // Obtain an element and cache the requested items.
    Condition cond = new PropertyCondition(AutomationElement.IsSelectionItemPatternAvailableProperty, true);
    AutomationElement elementListItem = elementList.FindFirst(TreeScope.Children, cond);

    // At this point, you could call another method that creates a CacheRequest and calls Push/Pop.
    // While that method was retrieving automation elements, the CacheRequest set in this method 
    // would not be active. 

    // Deactivate the request.
    cacheRequest.Pop();

    // Retrieve the cached property and pattern.
    String itemName = elementListItem.Cached.Name;
    SelectionItemPattern pattern = elementListItem.GetCachedPattern(SelectionItemPattern.Pattern) as SelectionItemPattern;

    // The following is an alternative way of retrieving the Name property.
    itemName = elementListItem.GetCachedPropertyValue(AutomationElement.NameProperty) as String;

    // This is yet another way, which returns AutomationElement.NotSupported if the element does
    // not supply a value. If the second parameter is false, a default name is returned.
    object objName = elementListItem.GetCachedPropertyValue(AutomationElement.NameProperty, true);
    if (objName == AutomationElement.NotSupported)
    {
        itemName = "Unknown";
    }
    else
    {
        itemName = objName as String;
    }

    // The following call raises an exception, because only the cached properties are available, 
    //  as specified by cacheRequest.AutomationElementMode. If AutomationElementMode had its
    //  default value (Full), this call would be valid.
    /*** bool enabled = elementListItem.Current.IsEnabled; ***/
}

Vedere anche

Concetti

Memorizzazione nella cache dei client di automazione interfaccia utente

Condividi tramite