Leer en inglés

Compartir a través de


Utilizar el almacenamiento en caché en la UI Automation

Nota

Esta documentación está dirigida a los desarrolladores de .NET Framework que quieran usar las clases de automatización de la interfaz de usuario administradas definidas en el espacio de nombres System.Windows.Automation. Para ver la información más reciente acerca de la automatización de la interfaz de usuario, consulte Windows Automation API: automatización de la interfaz de usuario.

En esta sección se muestra cómo implementar el almacenamiento en caché de patrones de control y propiedades de AutomationElement .

Activar una solicitud de almacenamiento en caché

  1. Crear un control CacheRequest.

  2. Especifique las propiedades y los patrones que se almacenarán en caché mediante el uso de Add.

  3. Especifique el ámbito del almacenamiento en caché estableciendo la propiedad TreeScope .

  4. Especifique la vista del subárbol estableciendo la propiedad TreeFilter .

  5. Establezca la propiedad AutomationElementMode en None si quiere aumentar la eficacia sin recuperar una referencia completa a objetos. (Esto hará que no sea posible recuperar los valores actuales de esos objetos).

  6. Active la solicitud mediante el uso de Activatedentro de un bloque using (Using en Microsoft Visual Basic .NET).

Después de obtener objetos AutomationElement o de suscribirse a eventos, desactive la solicitud mediante Pop (si se usó Push ) o eliminando el objeto creado por Activate. (Use Activate en un bloque using (Using en Microsoft Visual Basic .NET).

Propiedades de AutomationElement de almacenamiento en caché

  1. Mientras un elemento CacheRequest está activo, obtenga objetos AutomationElement mediante FindFirst o FindAll; u obtenga un elemento AutomationElement como el origen de un evento para el que se registró para cuando el elemento CacheRequest estaba activo. (También puede crear una caché pasando un elemento CacheRequest a GetUpdatedCache o uno de los métodos TreeWalker ).

  2. Use GetCachedPropertyValue o recupere una propiedad desde la propiedad Cached del elemento AutomationElement.

Obtener patrones almacenados en caché y sus propiedades

  1. Mientras un elemento CacheRequest está activo, obtenga objetos AutomationElement mediante FindFirst o FindAll; u obtenga un elemento AutomationElement como el origen de un evento para el que se registró para cuando el elemento CacheRequest estaba activo. (También puede crear una caché pasando un elemento CacheRequest a GetUpdatedCache o uno de los métodos TreeWalker ).

  2. Use GetCachedPattern o TryGetCachedPattern para recuperar un patrón almacenado en caché.

  3. Recupere valores de propiedad de la propiedad Cached del patrón de control.

Ejemplo 1

En el ejemplo de código siguiente se muestran varios aspectos del almacenamiento en caché en los que se usa Activate para activar el elemento 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 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;
}

Ejemplo 2

En el ejemplo de código siguiente se muestran varios aspectos del almacenamiento en caché en los que se usa Push para activar el elemento CacheRequest. Excepto cuando quiera anidar solicitudes de almacenamiento en caché, es preferible utilizar Activate.

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

Consulte también