AutomationElement.GetCurrentPattern(AutomationPattern) Metodo

  • Riferimento

Definizione

Spazio dei nomi:
System.Windows.Automation
Assembly:
UIAutomationClient.dll

Recupera l'oggetto del modello specificato su questo oggetto AutomationElement.

public:
 System::Object ^ GetCurrentPattern(System::Windows::Automation::AutomationPattern ^ pattern);
public object GetCurrentPattern (System.Windows.Automation.AutomationPattern pattern);
member this.GetCurrentPattern : System.Windows.Automation.AutomationPattern -> obj
Public Function GetCurrentPattern (pattern As AutomationPattern) As Object

Parametri

pattern
AutomationPattern

Identificatore del modello da recuperare.

Restituisce

Object

Oggetto del modello, se il modello specificato è attualmente supportato dall'oggetto AutomationElement.

Eccezioni

InvalidOperationException

Il pattern non è supportato dall'elemento.

ElementNotAvailableException

L'interfaccia utente per AutomationElement non esiste più.

Esempio

Nell'esempio seguente viene illustrato come utilizzare questo metodo per recuperare un SelectionItemPatternoggetto , che viene quindi utilizzato per selezionare un elemento in una casella di riepilogo.

/// <summary>
/// Sets the focus to a list and selects a string item in that list.
/// </summary>
/// <param name="listElement">The list element.</param>
/// <param name="itemText">The text to select.</param>
/// <remarks>
/// This deselects any currently selected items. To add the item to the current selection 
/// in a multiselect list, use AddToSelection instead of Select.
/// </remarks>
public void SelectListItem(AutomationElement listElement, String itemText)
{
    if ((listElement == null) || (itemText == ""))
    {
        throw new ArgumentException("Argument cannot be null or empty.");
    }
    listElement.SetFocus();
    Condition cond = new PropertyCondition(
        AutomationElement.NameProperty, itemText, PropertyConditionFlags.IgnoreCase);
    AutomationElement elementItem = listElement.FindFirst(TreeScope.Children, cond);
    if (elementItem != null)
    {
        SelectionItemPattern pattern;
        try
        {
            pattern = elementItem.GetCurrentPattern(SelectionItemPattern.Pattern) as SelectionItemPattern;
        }
        catch (InvalidOperationException ex)
        {
            Console.WriteLine(ex.Message);  // Most likely "Pattern not supported."
            return;
        }
        pattern.Select();
    }
}

''' <summary>
''' Sets the focus to a list and selects a string item in that list.
''' </summary>
''' <param name="listElement">The list element.</param>
''' <param name="itemText">The text to select.</param>
''' <remarks>
''' This deselects any currently selected items. To add the item to the current selection 
''' in a multiselect list, use AddToSelection instead of Select.
''' </remarks>
Public Sub SelectListItem(ByVal listElement As AutomationElement, ByVal itemText As String)
    If listElement Is Nothing OrElse itemText = "" Then
        Throw New ArgumentException("Argument cannot be null or empty.")
    End If
    listElement.SetFocus()
    Dim cond As New PropertyCondition(AutomationElement.NameProperty, itemText, PropertyConditionFlags.IgnoreCase)
    Dim elementItem As AutomationElement = listElement.FindFirst(TreeScope.Children, cond)
    If Not (elementItem Is Nothing) Then
        Dim pattern As SelectionItemPattern
        Try
            pattern = DirectCast(elementItem.GetCurrentPattern(SelectionItemPattern.Pattern), _
                SelectionItemPattern)
        Catch ex As InvalidOperationException
            Console.WriteLine(ex.Message) ' Most likely "Pattern not supported."
            Return
        End Try
        pattern.Select()
    End If

End Sub

Nota

Per le attività ripetute spesso, ad esempio quella nell'esempio, sarebbe più efficiente memorizzare nella cache il modello e usare GetCachedPattern.

Commenti

GetCurrentPattern ottiene il modello specificato in base alla disponibilità al momento della chiamata.

Per alcune forme di interfaccia utente, questo metodo comporta un sovraccarico delle prestazioni tra processi. Le applicazioni possono concentrarsi sull'overhead memorizzando nella cache i modelli e recuperandoli usando GetCachedPattern.

Si applica a

Vedi anche