Verwenden der Zwischenspeicherung in der Benutzeroberflächenautomatisierung

Artikel
08/10/2011

Hinweis
Diese Dokumentation ist für .NET Framework-Entwickler vorgesehen, die die verwalteten UI Automation-Klassen verwenden möchten, die im System.Windows.Automation-Namespace definiert sind.Aktuelle Informationen zu UI Automation finden Sie unter Windows Automation API: UI Automation.

In diesem Abschnitt wird gezeigt, wie das Zwischenspeichern von AutomationElement-Eigenschaften und Steuerelementmustern implementiert wird.

Aktivieren einer Cacheanforderung

Erstellen Sie eine CacheRequest.
Geben Sie Eigenschaften und Muster zum Zwischenspeichern mithilfe von Add an.
Geben Sie den Umfang des Zwischenspeicherns an, indem Sie die TreeScope-Eigenschaft festlegen.
Geben Sie die Ansicht der Teilstruktur an, indem Sie die TreeFilter-Eigenschaft festlegen.
Legen Sie für die AutomationElementMode-Eigenschaft None fest, wenn Sie die Effizienz steigern möchten, indem auf das Abrufen eines vollständigen Verweises auf Objekte verzichtet werden soll. (Dann ist es aber nicht mehr möglich, aus diesen Objekten aktuelle Werte abzurufen.)
Aktivieren Sie die Anforderung mithilfe von Activate innerhalb eines using-Blocks (Using in Microsoft Visual Basic .NET).

Deaktivieren Sie nach dem Abrufen von AutomationElement-Objekten oder dem Abonnieren von Ereignissen die Anforderung mithilfe von Pop (wenn Push verwendet wurde) oder indem Sie das durch Activate erstellte Objekt löschen. Verwenden Sie Activate in einem using-Block (Using in Microsoft Visual Basic .NET).

Cache-AutomationElement-Eigenschaften

Während ein CacheRequest aktiv ist, können Sie AutomationElement-Objekte mithilfe von FindFirst oder FindAll abrufen. Sie können ein AutomationElement-Objekt auch als Quelle eines Ereignisses abrufen, für dass Sie eine Registrierung vorgenommen haben, als der CacheRequest aktiv war. (Sie können einen Cache auch erstellen, indem Sie einen CacheRequest an GetUpdatedCache oder eine der TreeWalker-Methoden übergeben.)
Verwenden Sie GetCachedPropertyValue, oder rufen Sie eine Eigenschaft aus der Cached-Eigenschaft des AutomationElement-Objekts ab.

Abrufen von zwischengespeicherten Mustern und deren Eigenschaften

Während ein CacheRequest aktiv ist, können Sie AutomationElement-Objekte mithilfe von FindFirst oder FindAll abrufen. Sie können ein AutomationElement-Objekt auch als Quelle eines Ereignisses abrufen, für dass Sie eine Registrierung vorgenommen haben, als der CacheRequest aktiv war. (Sie können einen Cache auch erstellen, indem Sie einen CacheRequest an GetUpdatedCache oder eine der TreeWalker-Methoden übergeben.)
Verwenden Sie GetCachedPattern oder TryGetCachedPattern, um ein zwischengespeichertes Muster abzurufen.
Rufen Sie Eigenschaftswerte aus der Cached-Eigenschaft des Steuerelementmusters ab.

Beispiel

Im folgenden Codebeispiel werden die verschiedenen Möglichkeiten des Zwischenspeicherns gezeigt, indem Activate verwendet wird, um CacheRequest zu aktivieren.

    ''' <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;
}

m folgenden Codebeispiel werden die verschiedenen Möglichkeiten des Zwischenspeicherns gezeigt, indem Push verwendet wird, um CacheRequest zu aktivieren. Vorzugsweise sollte Activate verwendet werden, es sei denn, dass Cacheanforderungen geschachtelt werden sollen.

''' <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; ***/
}

Siehe auch

Konzepte

Zwischenspeichern in Benutzeroberflächenautomatisierungs-Clients

Freigeben über