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

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

Ejemplos

En este ejemplo se muestra la sintaxis básica para conectar un controlador de eventos con AddHandler y handledEventsToo como true. En este caso, el evento que se está conectando es Tapped. El lugar típico para conectar controladores es Cargado para una página o OnApplyTemplate para un control con plantilla.

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

Comentarios

No intentes usar AddHandler como sustituto general de la sintaxis específica del lenguaje que normalmente usas para los controladores de eventos de cableado; no funcionará, porque no todos los eventos tienen un identificador que se puede pasar como routedEvent. AddHandler está específicamente para eventos enrutados y está pensado principalmente para el escenario concreto habilitado pasando handledEventsToo como true. Para obtener más información, consulta Introducción a eventos y eventos enrutados.

Identificadores de eventos enrutados

El identificador de evento enrutado suele ser un miembro de propiedad estático de UIElement. Por ejemplo, para agregar un controlador para el evento KeyUp , pase KeyUpEvent para este parámetro. Solo un pequeño número de eventos de Windows Runtime tienen este identificador; solo los eventos enrutados en UIElement tienen una API de identificador disponible para este uso. Por lo general, estos son eventos relacionados con las acciones de entrada en varios niveles: nivel de puntero, nivel de gesto, nivel de manipulación. Además, los eventos de entrada clave se pueden controlar de esta manera.

Esta es una lista de eventos enrutados que exponen un identificador de evento enrutado y, por tanto, se pueden procesar mediante controladores registrados por una llamada a AddHandler:

• DoubleTapped
• DragEnter
• DragLeave
• DragOver
• Soltar
• Holding
• KeyDown
• KeyUp
• ManipulationCompleted
• ManipulationDelta
• ManipulationInertiaStarting
• ManipulationStarted
• ManipulationStarting
• PointerCanceled
• PointerCaptureLost
• PointerEntered
• PointerExited
• PointerMoved
• PointerPressed
• PointerReleased
• PointerWheelChanged
• RightTapped
• Tapped

Parámetro del controlador

El parámetro handler es un parámetro sin tipo, pero debe proporcionar un nuevo delegado que haga referencia a un método de controlador específico del evento deseado. Por ejemplo, si controla un evento KeyUp , pase una nueva instancia de KeyEventHandler que haga referencia a un método basado en esa firma de delegado KeyEventHandler . Esto requiere una desreferencia y la sintaxis de desreferencia varía en función del lenguaje que use. Consulte los ejemplos de este tema.

Cuándo usar handledEventsToo

El procesamiento de eventos de entrada de bajo nivel de forma práctica es una tarea compleja. Muchos controles implementan el comportamiento en el que un determinado evento se marca como controlado y se reemplaza por otro evento más intuitivo. Por lo general, un control marcará un evento enrutado como controlado solo si hay alguna intención de diseño para hacerlo. Sin embargo, en determinados escenarios, es posible que esas intenciones de diseño no sean las que requiere su control concreto del evento de entrada. Es para estos escenarios que el registro de controladores con handledEventsToo como true es adecuado. Pero no deberías hacer esto de forma rutinaria. Invocar controladores en respuesta a todos los eventos, incluso si se controla, complicará su propia lógica de procesamiento de eventos de la aplicación. Es posible que vea una disminución del rendimiento si la lógica del controlador es sustancial. Solo debe adjuntar controladores a eventos ya controlados si ha descubierto que determinados controles controlan los eventos que desea controlar con la lógica de la aplicación.

Otra técnica para evitar el comportamiento de control de clases de un control es subclase que controlan e invalidan sus métodos OnEvent , que son invalidaciones preconfiguradas por las que el control marca un evento como controlado. Sin embargo, esto también puede ser complejo. Es posible que tenga que reproducir la implementación de control de un control sin llamar a la implementación base, ya que la implementación base marcaría el evento como controlado. Para obtener más información, consulta Introducción a eventos y eventos enrutados.

Se aplica a

Consulte también

• RemoveHandler(RoutedEvent, Object)
• Introducción a eventos y eventos enrutados
• Control de la entrada con puntero