UIElement.AddHandler(RoutedEvent, Object, Boolean) Método

  • Referência

Definição

Namespace:
Windows.UI.Xaml
Editar

Adiciona um manipulador de eventos roteados de um evento roteado especificado, adicionando o manipulador à coleção de manipuladores no elemento atual. Especifique handledEventsToo como true para que o manipulador fornecido seja invocado mesmo se o evento for tratado em outro lugar.

public:
 virtual void AddHandler(RoutedEvent ^ routedEvent, Platform::Object ^ handler, bool handledEventsToo) = AddHandler;
void AddHandler(RoutedEvent const& routedEvent, IInspectable const& handler, bool const& handledEventsToo);
public void AddHandler(RoutedEvent routedEvent, object handler, bool handledEventsToo);
function addHandler(routedEvent, handler, handledEventsToo)
Public Sub AddHandler (routedEvent As RoutedEvent, handler As Object, handledEventsToo As Boolean)

Parâmetros

routedEvent
RoutedEvent

Um identificador do evento roteado a ser manipulado.

handler
Object

Platform::Object

IInspectable

Uma referência à implementação do manipulador.

handledEventsToo
Boolean

bool

true para registrar o manipulador de modo que ele seja invocado mesmo quando o evento roteado é marcado como manipulado em seus dados de evento.

false para registrar o manipulador com a condição padrão de que ele não será invocado se o evento roteado já estiver marcado como manipulado. O padrão é false.

Não peça rotineiramente para manipular novamente um evento roteado, pois ele interfere no design pretendido do sistema de eventos Windows Runtime para composição de controle.

Exemplos

Este exemplo mostra a sintaxe básica para conectar um manipulador de eventos com AddHandler e handledEventsToo como true. Nesse caso, o evento que está sendo conectado é Tocado. O lugar típico para manipuladores de fio é Carregado para uma página ou OnApplyTemplate para um controle com modelo.

void MyControl::MyPointerPressedHandler(
    winrt::Windows::Foundation::IInspectable const &sender,
    winrt::Windows::UI::Xaml::Input::PointerRoutedEventArgs const& e) {
  // implementation..
}

this->AddHandler(
    winrt::Windows::UI::Xaml::UIElement::PointerPressedEvent(),
    winrt::box_value(winrt::Windows::UI::Xaml::Input::PointerEventHandler(this, &MyControl::MyPointerPressedHandler)),
    true);

// Or passing the handler as a lambda, instead of a member function:
this->AddHandler(
    winrt::Windows::UI::Xaml::UIElement::PointerPressedEvent(),
    winrt::box_value(winrt::Windows::UI::Xaml::Input::PointerEventHandler(
      [=](auto &&, winrt::Windows::UI::Xaml::Input::PointerRoutedEventArgs const &args) {
      // ...
    })),
    true);    

void MainPage::pageRoot_Tapped(Platform::Object^ sender, Windows::UI::Xaml::Input::TappedRoutedEventArgs^ e)
{
     //implementation
}
void MainPage::pageRoot_Loaded(Platform::Object^ sender, Windows::UI::Xaml::RoutedEventArgs^ e)
{
     this->AddHandler(UIElement::TappedEvent, ref new TappedEventHandler(this, &MainPage::pageRoot_Tapped), true);
}

private void pageRoot_Tapped(object sender, TappedRoutedEventArgs e)
{
    //implementation
}
private void pageRoot_Loaded_1(object sender, RoutedEventArgs e)
{
    this.AddHandler(UIElement.TappedEvent, new TappedEventHandler(pageRoot_Tapped), true);
}

Private Sub Page_Tapped(sender As Object, e As TappedRoutedEventArgs)
    ' implementation
End Sub
Private Sub Page_Loaded_1(sender As Object, e As RoutedEventArgs)
    Me.AddHandler(UIElement.TappedEvent, New TappedEventHandler(AddressOf Page_Tapped), True)
End Sub

Comentários

Não tente usar AddHandler como um substituto geral para a sintaxe específica do idioma que você normalmente usa para manipuladores de eventos de fiação; não funcionará, pois nem todos os eventos têm um identificador que você pode passar como routedEvent. AddHandler é especificamente para eventos roteados e destina-se principalmente ao cenário específico habilitado passando handledEventsToo como true. Para saber mais, confira Visão geral de eventos e eventos roteados.

Identificadores de evento roteado

O identificador de evento roteado geralmente é um membro de propriedade estática de UIElement. Por exemplo, para adicionar um manipulador para o evento KeyUp , passe KeyUpEvent para esse parâmetro. Apenas um pequeno número de eventos Windows Runtime têm esse identificador; somente os eventos roteado no UIElement têm uma API de identificador disponível para esse uso. Geralmente, são eventos relacionados a ações de entrada em vários níveis: nível de ponteiro, nível de gesto, nível de manipulação. Além disso, os principais eventos de entrada podem ser tratados dessa maneira.

Aqui está uma lista de eventos roteados que expõem um identificador de evento roteado e, portanto, podem ser processados por manipuladores registrados por uma chamada AddHandler:

O parâmetro de manipulador

O parâmetro handler é um parâmetro não tipado, mas você deve fornecer um novo delegado que faça referência a um método de manipulador específico para o evento desejado. Por exemplo, se estiver manipulando um evento KeyUp , passe uma nova instância KeyEventHandler que referencie um método baseado nessa assinatura de delegado KeyEventHandler . Isso requer uma desreferência e a sintaxe de desreferência varia dependendo do idioma que você está usando. Consulte os exemplos neste tópico.

Quando usar handledEventsToo

Processar eventos de entrada de baixo nível de maneira prática é uma tarefa complexa. Muitos controles implementam o comportamento em que um determinado evento é marcado como manipulado e é substituído por outro evento mais intuitivo. Em geral, um controle marcará um evento roteado como manipulado somente se houver alguma intenção de design para fazer isso. No entanto, em determinados cenários, essas intenções de design podem não ser o que seu tratamento específico do evento de entrada requer. É para esses cenários que o registro de manipuladores com handledEventsToo como true é apropriado. Mas você não deve fazer isso rotineiramente. Invocar manipuladores em resposta a todos os eventos, mesmo se tratados, complicará sua própria lógica de processamento de eventos de aplicativo. Você poderá ver uma diminuição no desempenho se a lógica do manipulador for substancial. Você deve anexar manipuladores a eventos já manipulados somente se tiver descoberto que determinados controles estão manipulando eventos que você deseja manipular com a lógica do aplicativo.

Outra técnica para evitar o comportamento de manipulação de classe de um controle é subclasse que controla e substitui seus métodos OnEvent , que são substituições pré-configuradas pelas quais o controle marca um evento como manipulado. No entanto, isso também pode ser complexo. Talvez seja necessário reproduzir a implementação de tratamento de um controle sem chamar a implementação base, pois a implementação base marcaria o evento como manipulado. Para saber mais, confira Visão geral de eventos e eventos roteados.

Aplica-se a

Confira também