Información general sobre eventos enrutadosRouted Events Overview

En este tema se describe el concepto de eventos enrutados en Windows Presentation Foundation (WPF)Windows Presentation Foundation (WPF).This topic describes the concept of routed events in Windows Presentation Foundation (WPF)Windows Presentation Foundation (WPF). En el tema se define la terminología de los eventos enrutados, se describe cómo se enrutan a través de un árbol de elementos, se resume cómo controlar los eventos enrutados y se explica cómo crear sus propios eventos enrutados personalizados.The topic defines routed events terminology, describes how routed events are routed through a tree of elements, summarizes how you handle routed events, and introduces how to create your own custom routed events.

Requisitos previosPrerequisites

En este tema se supone que tiene conocimientos básicos del Common Language Runtime (CLR)common language runtime (CLR) y de la programación orientada a objetos, así como de la noción de cómo se pueden conceptualizar como un árbol las relaciones entre los elementos de WPFWPF.This topic assumes that you have basic knowledge of the Common Language Runtime (CLR)common language runtime (CLR) and object-oriented programming, as well as the concept of how the relationships between WPFWPF elements can be conceptualized as a tree. Para seguir los ejemplos de este tema, también debe comprender Lenguaje XAML (Extensible Application Markup Language)Extensible Application Markup Language (XAML) y saber cómo escribir páginas o aplicaciones de WPFWPF muy básicas.In order to follow the examples in this topic, you should also understand Lenguaje XAML (Extensible Application Markup Language)Extensible Application Markup Language (XAML) and know how to write very basic WPFWPF applications or pages. Para obtener más información, consulte Tutorial: Mi primera aplicación de escritorio de WPF y información general sobre XAML (WPF).For more information, see Walkthrough: My first WPF desktop application and XAML Overview (WPF).

¿Qué es un evento enrutado?What Is a Routed Event?

Los eventos enrutados se pueden considerar desde dos perspectivas: funcional y de implementación.You can think about routed events either from a functional or implementation perspective. Aquí se presentan ambas definiciones, dado que algunas personas encuentran que una es más útil que la otra.Both definitions are presented here, because some people find one or the other definition more useful.

Definición funcional: un evento enrutado es un tipo de evento que puede invocar controladores en varios agentes de escucha en un árbol de elementos, en lugar de simplemente en el objeto que ha generado el evento.Functional definition: A routed event is a type of event that can invoke handlers on multiple listeners in an element tree, rather than just on the object that raised the event.

Definición de implementación: es un evento enrutado un CLRCLR evento que está respaldado por una instancia de la RoutedEvent clase y se procesa mediante el Windows Presentation Foundation (WPF)Windows Presentation Foundation (WPF) sistema de eventos.Implementation definition: A routed event is a CLRCLR event that is backed by an instance of the RoutedEvent class and is processed by the Windows Presentation Foundation (WPF)Windows Presentation Foundation (WPF) event system.

Una aplicación típica de WPFWPF contiene muchos elementos.A typical WPFWPF application contains many elements. Tanto si se crean en código como si se declaran en XAMLXAML, estos elementos se relacionan entre sí a través de un árbol de elementos.Whether created in code or declared in XAMLXAML, these elements exist in an element tree relationship to each other. En función de la definición del evento, la ruta de eventos puede viajar en cualquiera de las dos direcciones, pero generalmente viaja desde el elemento de origen y, después, "se propaga" en sentido ascendente por el árbol de elementos hasta que llega a la raíz (normalmente una página o una ventana).The event route can travel in one of two directions depending on the event definition, but generally the route travels from the source element and then "bubbles" upward through the element tree until it reaches the element tree root (typically a page or a window). Es posible que este concepto de propagación le resulte familiar si ha trabajado previamente con el modelo de objetos DHTML.This bubbling concept might be familiar to you if you have worked with the DHTML object model previously.

Considere el siguiente árbol de elementos simple:Consider the following simple element tree:

<Border Height="50" Width="300" BorderBrush="Gray" BorderThickness="1">
  <StackPanel Background="LightGray" Orientation="Horizontal" Button.Click="CommonClickHandler">
    <Button Name="YesButton" Width="Auto" >Yes</Button>
    <Button Name="NoButton" Width="Auto" >No</Button>
    <Button Name="CancelButton" Width="Auto" >Cancel</Button>
  </StackPanel>
</Border>

Este árbol de elementos genera algo parecido a lo siguiente:This element tree produces something like the following:

Botones Yes, No y CancelYes, No, and Cancel buttons

En este árbol de elementos simplificada, el origen de un Click evento es uno de los Button elementos y lo que Button se hizo clic es el primer elemento que tiene la oportunidad de controlar el evento.In this simplified element tree, the source of a Click event is one of the Button elements, and whichever Button was clicked is the first element that has the opportunity to handle the event. Sin embargo, si no hay ningún controlador asociado a la Button actúa sobre el evento, a continuación, el evento se propaga hacia arriba a la Button entidad primaria en el árbol de elementos, que es el StackPanel.But if no handler attached to the Button acts on the event, then the event will bubble upwards to the Button parent in the element tree, which is the StackPanel. Potencialmente, el evento se propaga a Bordery, a continuación, continúa hacia la raíz de la página del árbol de elementos (no se muestra).Potentially, the event bubbles to Border, and then beyond to the page root of the element tree (not shown).

En otras palabras, la ruta del evento para este Click evento es:In other words, the event route for this Click event is:

Botón-->StackPanel-->Borde-->...Button-->StackPanel-->Border-->...

Escenarios de nivel superior para los eventos enrutadosTop-level Scenarios for Routed Events

A continuación se muestra un breve resumen de los escenarios que han motivado el concepto de evento enrutado y por qué un evento CLRCLR típico no resultaba adecuado para estos escenarios:The following is a brief summary of the scenarios that motivated the routed event concept, and why a typical CLRCLR event was not adequate for these scenarios:

Encapsulación y composición de controles: varios controles de WPFWPF tienen un modelo de contenido enriquecido.Control composition and encapsulation: Various controls in WPFWPF have a rich content model. Por ejemplo, puede colocar una imagen dentro de un Button, que extiende eficazmente el árbol visual del botón.For example, you can place an image inside of a Button, which effectively extends the visual tree of the button. Sin embargo, la imagen agregada no debe interrumpir el comportamiento de la prueba de posicionamiento que hace que un botón responder a un Click de su contenido, incluso si el usuario hace clic en píxeles que técnicamente forman parte de la imagen.However, the added image must not break the hit-testing behavior that causes a button to respond to a Click of its content, even if the user clicks on pixels that are technically part of the image.

Puntos de unión de controladores únicos: en Windows FormsWindows Forms, era necesario adjuntar varias veces el mismo controlador para procesar eventos que podrían desencadenarse desde varios elementos.Singular handler attachment points: In Windows FormsWindows Forms, you would have to attach the same handler multiple times to process events that could be raised from multiple elements. Los eventos enrutados le permiten asociar ese controlador una sola vez, tal como se ha mostrado en el ejemplo anterior, y usar la lógica del controlador para determinar el origen del evento si fuera necesario.Routed events enable you to attach that handler only once, as was shown in the previous example, and use handler logic to determine where the event came from if necessary. Por ejemplo, este podría ser el controlador para el XAMLXAML mostrado anteriormente:For instance, this might be the handler for the previously shown XAMLXAML:

private void CommonClickHandler(object sender, RoutedEventArgs e)
{
  FrameworkElement feSource = e.Source as FrameworkElement;
  switch (feSource.Name)
  {
    case "YesButton":
      // do something here ...
      break;
    case "NoButton":
      // do something ...
      break;
    case "CancelButton":
      // do something ...
      break;
  }
  e.Handled=true;
}
 Private Sub CommonClickHandler(ByVal sender As Object, ByVal e As RoutedEventArgs)
Dim feSource As FrameworkElement = TryCast(e.Source, FrameworkElement)
Select Case feSource.Name
  Case "YesButton"
	' do something here ...
  Case "NoButton"
	' do something ...
  Case "CancelButton"
	' do something ...
End Select
e.Handled=True
 End Sub

Control de clases: los eventos enrutados permiten un controlador estático definido por la clase.Class handling: Routed events permit a static handler that is defined by the class. Este controlador de clase tiene la oportunidad de controlar un evento antes de que pueda hacerlo cualquiera de los controladores de instancia asociados.This class handler has the opportunity to handle an event before any attached instance handlers can.

Hacer referencia a un evento sin reflexión: determinadas técnicas de código y de marcado requieren una manera de identificar un evento concreto.Referencing an event without reflection: Certain code and markup techniques require a way to identify a specific event. Crea un evento enrutado un RoutedEvent campo como un identificador, que proporciona una técnica de identificación de sucesos robusto que no requiere la reflexión estática o en tiempo de ejecución.A routed event creates a RoutedEvent field as an identifier, which provides a robust event identification technique that does not require static or run-time reflection.

Cómo se implementan los eventos enrutadosHow Routed Events Are Implemented

Un evento enrutado es un CLRCLR evento que está respaldado por una instancia de la RoutedEvent clase y registrados con el WPFWPF sistema de eventos.A routed event is a CLRCLR event that is backed by an instance of the RoutedEvent class and registered with the WPFWPF event system. El RoutedEvent instancia obtenida del registro normalmente se retiene como un public static readonly miembro de campo de la clase que registra y, por tanto, el "propietario" del evento enrutado.The RoutedEvent instance obtained from registration is typically retained as a public static readonly field member of the class that registers and thus "owns" the routed event. La conexión con el evento de CLRCLR del mismo nombre (que a veces se denomina el evento "contenedor") se logra reemplazando las implementaciones add y remove para el evento de CLRCLR.The connection to the identically named CLRCLR event (which is sometimes termed the "wrapper" event) is accomplished by overriding the add and remove implementations for the CLRCLR event. Normalmente, add y remove se dejan como un valor predeterminado implícito que usa la sintaxis de eventos específica del lenguaje adecuada para agregar y quitar controladores de ese evento.Ordinarily, the add and remove are left as an implicit default that uses the appropriate language-specific event syntax for adding and removing handlers of that event. El mecanismo de copia de seguridad y conexión de eventos enrutados es conceptualmente similar a cómo una propiedad de dependencia es un CLRCLR propiedad que está respaldado por la DependencyProperty clase y registrados con el WPFWPF sistema de propiedades.The routed event backing and connection mechanism is conceptually similar to how a dependency property is a CLRCLR property that is backed by the DependencyProperty class and registered with the WPFWPF property system.

En el ejemplo siguiente se muestra la declaración de un personalizado Tap eventos enrutados, incluidos el registro y la exposición de la RoutedEvent campo de identificador y el add y remove implementaciones para la Tap CLRCLR eventos.The following example shows the declaration for a custom Tap routed event, including the registration and exposure of the RoutedEvent identifier field and the add and remove implementations for the Tap CLRCLR event.

public static readonly RoutedEvent TapEvent = EventManager.RegisterRoutedEvent(
    "Tap", RoutingStrategy.Bubble, typeof(RoutedEventHandler), typeof(MyButtonSimple));

// Provide CLR accessors for the event
public event RoutedEventHandler Tap
{
        add { AddHandler(TapEvent, value); } 
        remove { RemoveHandler(TapEvent, value); }
}
Public Shared ReadOnly TapEvent As RoutedEvent = EventManager.RegisterRoutedEvent("Tap", RoutingStrategy.Bubble, GetType(RoutedEventHandler), GetType(MyButtonSimple))

' Provide CLR accessors for the event
Public Custom Event Tap As RoutedEventHandler
    AddHandler(ByVal value As RoutedEventHandler)
        Me.AddHandler(TapEvent, value)
    End AddHandler

    RemoveHandler(ByVal value As RoutedEventHandler)
        Me.RemoveHandler(TapEvent, value)
    End RemoveHandler

    RaiseEvent(ByVal sender As Object, ByVal e As RoutedEventArgs)
        Me.RaiseEvent(e)
    End RaiseEvent
End Event

Controladores de eventos enrutados y XAMLRouted Event Handlers and XAML

Para agregar un controlador para un evento mediante XAMLXAML, declare el nombre del evento como un atributo en el elemento que actúa como agente de escucha de eventos.To add a handler for an event using XAMLXAML, you declare the event name as an attribute on the element that is an event listener. El valor del atributo es el nombre de su método de controlador implementado, que debe existir en la clase parcial del archivo de código subyacente.The value of the attribute is the name of your implemented handler method, which must exist in the partial class of the code-behind file.

<Button Click="b1SetColor">button</Button>

La sintaxis de XAMLXAML para agregar controladores de eventos de CLRCLR estándar es la misma que la que se usa para agregar controladores de eventos enrutados, porque realmente se están agregando controladores al contenedor de eventos de CLRCLR, que se basa en una implementación de eventos enrutados.The XAMLXAML syntax for adding standard CLRCLR event handlers is the same for adding routed event handlers, because you are really adding handlers to the CLRCLR event wrapper, which has a routed event implementation underneath. Para más información sobre cómo agregar controladores de eventos en XAMLXAML, vea Información general sobre XAML (WPF).For more information about adding event handlers in XAMLXAML, see XAML Overview (WPF).

Estrategias de enrutamientoRouting Strategies

Los eventos enrutados usan una de estas tres estrategias de enrutamiento:Routed events use one of three routing strategies:

  • Propagación: se invocan los controladores de eventos en el origen del evento.Bubbling: Event handlers on the event source are invoked. Después, el evento enrutado va pasando por los elementos primarios sucesivos hasta alcanzar la raíz del árbol de elementos.The routed event then routes to successive parent elements until reaching the element tree root. La mayoría de los eventos enrutados usan la estrategia del enrutamiento de propagación.Most routed events use the bubbling routing strategy. Los eventos con enrutamiento de propagación generalmente se usan para informar sobre cambios de entrada o de estado procedentes de controles distintos u otros elementos de la interfaz de usuario.Bubbling routed events are generally used to report input or state changes from distinct controls or other UI elements.

  • Directo: solo el propio elemento de origen tiene la oportunidad de invocar controladores como respuesta.Direct: Only the source element itself is given the opportunity to invoke handlers in response. Esto es análogo al "enrutamiento" que usa Windows FormsWindows Forms para los eventos.This is analogous to the "routing" that Windows FormsWindows Forms uses for events. Sin embargo, a diferencia de un estándar CLRCLR eventos, dirigir los eventos enrutados admiten control de clases (control de clases se explica en una sección posterior) y puede usarse en EventSetter y EventTrigger.However, unlike a standard CLRCLR event, direct routed events support class handling (class handling is explained in an upcoming section) and can be used by EventSetter and EventTrigger.

  • Tunelización: inicialmente, se invocan los controladores de eventos en la raíz del árbol de elementos.Tunneling: Initially, event handlers at the element tree root are invoked. Después, el evento enrutado viaja a través de los elementos secundarios sucesivos a lo largo de la ruta, hacia el elemento de nodo que es el origen del evento enrutado (el elemento que ha desencadenado el evento enrutado).The routed event then travels a route through successive child elements along the route, towards the node element that is the routed event source (the element that raised the routed event). Los eventos con enrutamiento de tunelización se suelen usar o controlar como parte de la composición de un control, de forma que los eventos de las partes compuestas se puedan suprimir o reemplazar deliberadamente por eventos que son específicos del control completo.Tunneling routed events are often used or handled as part of the compositing for a control, such that events from composite parts can be deliberately suppressed or replaced by events that are specific to the complete control. Los eventos de entrada proporcionados en WPFWPF se suelen implementar como un par de tunelización-propagación.Input events provided in WPFWPF often come implemented as a tunneling/bubbling pair. Los eventos de tunelización también se conocen a veces como eventos de vista previa, debido a una convención de nomenclatura que se usa para los pares.Tunneling events are also sometimes referred to as Preview events, because of a naming convention that is used for the pairs.

¿Por qué usar eventos enrutados?Why Use Routed Events?

Como desarrollador de aplicaciones, no siempre necesita saber ni preocuparse de si el evento que está controlando se implementa como un evento enrutado.As an application developer, you do not always need to know or care that the event you are handling is implemented as a routed event. Los eventos enrutados tienen un comportamiento especial, pero ese comportamiento es prácticamente invisible si está controlando un evento en el elemento donde se desencadena.Routed events have special behavior, but that behavior is largely invisible if you are handling an event on the element where it is raised.

Los eventos enrutados demuestran su eficacia cuando se usa cualquiera de los escenarios sugeridos: definir los controladores comunes en una raíz común, componer un control personalizado o definir una clase de controles personalizada.Where routed events become powerful is if you use any of the suggested scenarios: defining common handlers at a common root, compositing your own control, or defining your own custom control class.

Los agentes de escucha y los orígenes de los eventos enrutados no necesitan compartir un evento común en su jerarquía.Routed event listeners and routed event sources do not need to share a common event in their hierarchy. Cualquier UIElement o ContentElement puede ser un agente de escucha de eventos para los eventos enrutados.Any UIElement or ContentElement can be an event listener for any routed event. Por tanto, se puede usar todo el conjunto de eventos enrutados disponibles en la APIAPI activa como una "interfaz" conceptual en la que elementos dispares de la aplicación pueden intercambiar información sobre los eventos.Therefore, you can use the full set of routed events available throughout the working APIAPI set as a conceptual "interface" whereby disparate elements in the application can exchange event information. Este concepto de "interfaz" para los eventos enrutados es especialmente aplicable a los eventos de entrada.This "interface" concept for routed events is particularly applicable for input events.

Los eventos enrutados también se pueden usar para comunicar datos a través del árbol de elementos, porque los datos de evento para cada evento se perpetúan en cada elemento de la ruta.Routed events can also be used to communicate through the element tree, because the event data for the event is perpetuated to each element in the route. Un elemento podría cambiar algo en los datos del evento, y ese cambio estaría disponible para el elemento siguiente de la ruta.One element could change something in the event data, and that change would be available to the next element in the route.

Aparte del aspecto del enrutamiento, hay otros dos motivos por los que cualquier evento de WPFWPF se podría implementar como un evento enrutado en lugar de un evento CLRCLR estándar.Other than the routing aspect, there are two other reasons that any given WPFWPF event might be implemented as a routed event instead of a standard CLRCLR event. Si está implementando sus propios eventos, también podría considerar estos principios:If you are implementing your own events, you might also consider these principles:

  • Ciertos WPFWPF otras características, como aplicar estilos y plantillas EventSetter y EventTrigger requieren el evento que se hace referencia como un evento enrutado.Certain WPFWPF styling and templating features such as EventSetter and EventTrigger require the referenced event to be a routed event. Este es el escenario del identificador de eventos mencionado anteriormente.This is the event identifier scenario mentioned earlier.

  • Los eventos enrutados admiten un mecanismo de control de clases en el que la clase puede especificar métodos estáticos que tienen la oportunidad de controlar eventos enrutados antes de que cualquier controlador de instancias registrado tenga acceso a ellos.Routed events support a class handling mechanism whereby the class can specify static methods that have the opportunity to handle routed events before any registered instance handlers can access them. Esto es muy útil en el diseño de controles, porque una clase puede exigir comportamientos de clase orientados a eventos que no se puedan suprimir accidentalmente controlando un evento en una instancia.This is very useful in control design, because your class can enforce event-driven class behaviors that cannot be accidentally suppressed by handling an event on an instance.

Cada una de las consideraciones anteriores se explica en una sección independiente de este tema.Each of the above considerations is discussed in a separate section of this topic.

Agregar e implementar un controlador de eventos para un evento enrutadoAdding and Implementing an Event Handler for a Routed Event

Para agregar un controlador de eventos en XAMLXAML, simplemente agregue el nombre del evento a un elemento como un atributo y establezca el valor del atributo como el nombre del controlador de eventos que implementa un delegado adecuado, como en el ejemplo siguiente.To add an event handler in XAMLXAML, you simply add the event name to an element as an attribute and set the attribute value as the name of the event handler that implements an appropriate delegate, as in the following example.

<Button Click="b1SetColor">button</Button>

b1SetColor es el nombre del controlador implementado que contiene el código que controla el Click eventos.b1SetColor is the name of the implemented handler that contains the code that handles the Click event. b1SetColor debe tener la misma firma que el RoutedEventHandler delegado, que es el delegado de controlador de eventos para el Click eventos.b1SetColor must have the same signature as the RoutedEventHandler delegate, which is the event handler delegate for the Click event. El primer parámetro de todos los delegados de controlador de eventos enrutados especifica el elemento al que se agrega el controlador de eventos y el segundo parámetro especifica los datos para el evento.The first parameter of all routed event handler delegates specifies the element to which the event handler is added, and the second parameter specifies the data for the event.

void b1SetColor(object sender, RoutedEventArgs args)
{
  //logic to handle the Click event
}
 Private Sub b1SetColor(ByVal sender As Object, ByVal args As RoutedEventArgs)
'logic to handle the Click event
 End Sub

RoutedEventHandler es el delegado de controlador de eventos enrutados básico.RoutedEventHandler is the basic routed event handler delegate. Para los eventos enrutados especializados para ciertos controles o escenarios, los delegados que deben usarse para los controladores de eventos enrutados también podrían volverse más especializados, de forma que puedan transmitir datos de evento especializados.For routed events that are specialized for certain controls or scenarios, the delegates to use for the routed event handlers also might become more specialized, so that they can transmit specialized event data. Por ejemplo, en un escenario de entrada común, puede controlar un DragEnter evento enrutado.For instance, in a common input scenario, you might handle a DragEnter routed event. El controlador debe implementar la DragEventHandler delegar.Your handler should implement the DragEventHandler delegate. Al usar el delegado más específico, puede procesar el DragEventArgs en el controlador y leer la Data propiedad, que contiene la carga del Portapapeles de la operación de arrastre.By using the most specific delegate, you can process the DragEventArgs in the handler and read the Data property, which contains the clipboard payload of the drag operation.

Para obtener un ejemplo completo de cómo agregar un controlador de eventos a un elemento mediante XAMLXAML, vea Cómo: Controlar un evento enrutado.For a complete example of how to add an event handler to an element using XAMLXAML, see Handle a Routed Event.

Resulta sencillo agregar un controlador para un evento enrutado en una aplicación que se crea en el código.Adding a handler for a routed event in an application that is created in code is straightforward. Siempre se pueden agregar controladores de eventos enrutados a través de un método auxiliar AddHandler (que es el mismo método que llama a la copia de seguridad existente para add.) Pero los eventos enrutados existentes de WPFWPF generalmente tienen implementaciones de respaldo de lógica add y remove que permiten agregar los controladores para eventos enrutados mediante una sintaxis de eventos específica del lenguaje, que es una sintaxis más intuitiva que el método auxiliar.Routed event handlers can always be added through a helper method AddHandler (which is the same method that the existing backing calls for add.) However, existing WPFWPF routed events generally have backing implementations of add and remove logic that allow the handlers for routed events to be added by a language-specific event syntax, which is more intuitive syntax than the helper method. A continuación se muestra un ejemplo de uso del método auxiliar:The following is an example usage of the helper method:

void MakeButton()
 {
     Button b2 = new Button();
     b2.AddHandler(Button.ClickEvent, new RoutedEventHandler(Onb2Click));
 }
 void Onb2Click(object sender, RoutedEventArgs e)
 {
     //logic to handle the Click event     
 }
  Private Sub MakeButton()
	Dim b2 As New Button()
	b2.AddHandler(Button.ClickEvent, New RoutedEventHandler(AddressOf Onb2Click))
  End Sub
Private Sub Onb2Click(ByVal sender As Object, ByVal e As RoutedEventArgs)
	'logic to handle the Click event     
End Sub

El siguiente ejemplo se muestra en C# sintaxis del operador (Visual Basic tiene sintaxis del operador ligeramente diferente debido a su propio control de desreferenciar):The next example shows the C# operator syntax (Visual Basic has slightly different operator syntax because of its handling of dereferencing):

void MakeButton2()
{
  Button b2 = new Button();
  b2.Click += new RoutedEventHandler(Onb2Click2);
}
void Onb2Click2(object sender, RoutedEventArgs e)
{
  //logic to handle the Click event     
}
Private Sub MakeButton2()
  Dim b2 As New Button()
  AddHandler b2.Click, AddressOf Onb2Click2
End Sub
Private Sub Onb2Click2(ByVal sender As Object, ByVal e As RoutedEventArgs)
  'logic to handle the Click event     
End Sub

Para obtener un ejemplo de cómo agregar un controlador de eventos en el código, vea Agregar un controlador de eventos mediante código.For an example of how to add an event handler in code, see Add an Event Handler Using Code.

Si se utiliza Visual Basic, también puede usar el Handles palabra clave para agregar controladores como parte de las declaraciones del controlador.If you are using Visual Basic, you can also use the Handles keyword to add handlers as part of the handler declarations. Para más información, vea Control de eventos en Visual Basic y WPF.For more information, see Visual Basic and WPF Event Handling.

El concepto de controladoThe Concept of Handled

Todos los eventos enrutados comparten una evento datos clase base común, RoutedEventArgs.All routed events share a common event data base class, RoutedEventArgs. RoutedEventArgs define la Handled propiedad, que toma un valor booleano.RoutedEventArgs defines the Handled property, which takes a Boolean value. El propósito de la Handled propiedad es permitir que cualquier controlador de eventos a lo largo de la ruta para marcar el evento enrutado como controla, estableciendo el valor de Handled a true.The purpose of the Handled property is to enable any event handler along the route to mark the routed event as handled, by setting the value of Handled to true. Una vez procesados por el controlador de un elemento a lo largo de la ruta, se informa de nuevo sobre los datos de evento compartidos a cada agente de escucha a lo largo de la ruta.After being processed by the handler at one element along the route, the shared event data is again reported to each listener along the route.

El valor de Handled afecta a cómo se notifica un evento enrutado o se procesan cuando recorre más a lo largo de la ruta.The value of Handled affects how a routed event is reported or processed as it travels further along the route. Si Handled es true en el evento datos para un evento enrutado y, a continuación, los controladores que realizan escuchas para ese evento enrutado en otros elementos generalmente están ya no se invoca para esa instancia concreta del evento.If Handled is true in the event data for a routed event, then handlers that listen for that routed event on other elements are generally no longer invoked for that particular event instance. Esto se cumple tanto para los controladores adjuntos en XAMLXAML como para los controladores agregados mediante sintaxis de adjuntar controladores de eventos específicas del lenguaje como += o Handles.This is true both for handlers attached in XAMLXAML and for handlers added by language-specific event handler attachment syntaxes such as += or Handles. Para los escenarios más comunes de controlador, marcar un evento como controlado estableciendo Handled a true "dejará de" enrutamiento para una ruta de tunelización o una ruta de propagación y también para cualquier evento que se controla en un punto de la ruta mediante un controlador de clase.For most common handler scenarios, marking an event as handled by setting Handled to true will "stop" routing for either a tunneling route or a bubbling route, and also for any event that is handled at a point in the route by a class handler.

Sin embargo, hay un mecanismo de "handledEventsToo" mediante el cual los agentes de escucha pueden ejecutar controladores en respuesta a los eventos enrutados donde Handled es true en los datos del evento.However, there is a "handledEventsToo" mechanism whereby listeners can still run handlers in response to routed events where Handled is true in the event data. Es decir, la ruta de eventos no se detiene realmente al marcar los datos de evento como controlados.In other words, the event route is not truly stopped by marking the event data as handled. Sólo puede utilizar el mecanismo handledEventsToo en código o en un EventSetter:You can only use the handledEventsToo mechanism in code, or in an EventSetter:

Aparte del comportamiento que Handled genera el estado de los eventos enrutados, el concepto de Handled tiene implicaciones de cómo debe diseñar la aplicación y escribir el código del controlador de eventos.In addition to the behavior that Handled state produces in routed events, the concept of Handled has implications for how you should design your application and write the event handler code. Puede conceptualizar Handled como un protocolo simple que se expone mediante los eventos enrutados.You can conceptualize Handled as being a simple protocol that is exposed by routed events. Exactamente cómo usar este protocolo es hasta, pero el diseño conceptual sobre cómo el valor de Handled está prevista su utilización es como sigue:Exactly how you use this protocol is up to you, but the conceptual design for how the value of Handled is intended to be used is as follows:

  • Si un evento enrutado está marcado como controlado, no es necesario que los demás elementos a lo largo de esa ruta lo controlen de nuevo.If a routed event is marked as handled, then it does not need to be handled again by other elements along that route.

  • Si un evento enrutado no está marcado como controlado, otros agentes de escucha que estaban anteriores a lo largo de la ruta que han elegido no al registrar un controlador o los controladores que estaban registrado elegía no para manipular los datos del evento y establecer Handled a true.If a routed event is not marked as handled, then other listeners that were earlier along the route have chosen either not to register a handler, or the handlers that were registered chose not to manipulate the event data and set Handled to true. (O bien, es posible que el agente de escucha actual sea el primer punto de la ruta). Ahora los controladores del agente de escucha actual tienen tres posibles líneas de acción:(Or, it is of course possible that the current listener is the first point in the route.) Handlers on the current listener now have three possible courses of action:

    • No realizar ninguna acción; el evento sigue estando sin controlar y se enruta al agente de escucha siguiente.Take no action at all; the event remains unhandled, and the event routes to the next listener.

    • Ejecutar código en respuesta al evento, pero tomar la determinación de que la acción realizada no ha sido lo suficientemente sustancial como para marcar el evento como controlado.Execute code in response to the event, but make the determination that the action taken was not substantial enough to warrant marking the event as handled. El evento se enruta al agente de escucha siguiente.The event routes to the next listener.

    • Ejecutar código en respuesta al evento.Execute code in response to the event. Marcar el evento como controlado en los datos de evento pasados al controlador, porque la acción realizada se ha considerado lo suficientemente sustancial como para marcarlo como controlado.Mark the event as handled in the event data passed to the handler, because the action taken was deemed substantial enough to warrant marking as handled. El evento se enruta al agente de escucha siguiente, pero con Handled = true en los datos de evento, por lo que solo handledEventsToo los agentes de escucha tienen la oportunidad de invocar más controladores.The event still routes to the next listener, but with Handled=true in its event data, so only handledEventsToo listeners have the opportunity to invoke further handlers.

El comportamiento de enrutamiento se ha mencionado anteriormente refuerza este diseño conceptual: es más difícil (aunque todavía posible mediante código o estilos) adjuntar controladores para los eventos enrutados que se invocan incluso si un controlador anterior a lo largo de la ruta ya ha configurado Handleda true.This conceptual design is reinforced by the routing behavior mentioned earlier: it is more difficult (although still possible in code or styles) to attach handlers for routed events that are invoked even if a previous handler along the route has already set Handled to true.

Para obtener más información acerca de Handled, control de clases de eventos enrutados y recomendaciones acerca de cuándo es adecuado para marcar un evento enrutado como Handled, consulte Marcar eventos enrutados como Handled and Class Handling.For more information about Handled, class handling of routed events, and recommendations about when it is appropriate to mark a routed event as Handled, see Marking Routed Events as Handled, and Class Handling.

En las aplicaciones, es bastante habitual controlar un evento enrutado de propagación solamente en el objeto que lo ha desencadenado, y no preocuparse en absoluto por las características de enrutado del evento.In applications, it is quite common to just handle a bubbling routed event on the object that raised it, and not be concerned with the event's routing characteristics at all. Pero es una buena práctica marcar el evento enrutado como controlado en los datos de evento para evitar efectos secundarios imprevistos en caso de que un elemento situado más arriba en el árbol de elementos también tenga un controlador asociado para ese mismo evento enrutado.However, it is still a good practice to mark the routed event as handled in the event data, to prevent unanticipated side effects just in case an element that is further up the element tree also has a handler attached for that same routed event.

Controladores de claseClass Handlers

Si está definiendo una clase que deriva de alguna manera de DependencyObject, también puede definir y asociar un controlador de clase para un evento enrutado que es un miembro de evento declarado o heredado de la clase.If you are defining a class that derives in some way from DependencyObject, you can also define and attach a class handler for a routed event that is a declared or inherited event member of your class. Los controladores de clase se invocan antes que cualquier controlador de agente de escucha de instancia que esté asociado a una instancia de esa clase, cada vez que un evento enrutado alcanza una instancia de elemento en su ruta.Class handlers are invoked before any instance listener handlers that are attached to an instance of that class, whenever a routed event reaches an element instance in its route.

Algunos controles de WPFWPF tienen el control de clase inherente para ciertos eventos enrutados.Some WPFWPF controls have inherent class handling for certain routed events. Esto podría dar la impresión de que el evento enrutado nunca se genera, pero en realidad está sujeto al control de clase y sus controladores de instancia todavía pueden controlar el evento enrutado si emplea ciertas técnicas.This might give the outward appearance that the routed event is not ever raised, but in reality it is being class handled, and the routed event can potentially still be handled by your instance handlers if you use certain techniques. Además, muchas clases y controles base exponen métodos virtuales que se pueden usar para invalidar el comportamiento del control de clase.Also, many base classes and controls expose virtual methods that can be used to override class handling behavior. Para más información sobre cómo evitar el control de clase no deseado y cómo definir su propio control de clase en una clase personalizada, vea Marcar eventos enrutados como controlados y control de clases.For more information both on how to work around undesired class handling and on defining your own class handling in a custom class, see Marking Routed Events as Handled, and Class Handling.

Evento adjuntos en WPFAttached Events in WPF

El lenguaje XAMLXAML también define un tipo especial de evento denominado evento adjunto.The XAMLXAML language also defines a special type of event called an attached event. Un evento adjunto permite agregar un controlador para un evento determinado a un elemento arbitrario.An attached event enables you to add a handler for a particular event to an arbitrary element. No es necesario que el elemento que controla el evento defina o herede el evento adjunto, y ni el objeto que genera potencialmente el evento ni la instancia que controla el destino deben definir o ser "propietarios" de ese evento como miembro de clase.The element handling the event need not define or inherit the attached event, and neither the object potentially raising the event nor the destination handling instance must define or otherwise "own" that event as a class member.

El sistema de entrada de WPFWPF emplea mucho los eventos adjuntos.The WPFWPF input system uses attached events extensively. Pero casi todos estos eventos adjuntos se reenvían a través de elementos base.However, nearly all of these attached events are forwarded through base elements. Los eventos de entrada aparecen como eventos enrutados no adjuntos equivalentes que son miembros de la clase de elemento base.The input events then appear as equivalent non-attached routed events that are members of the base element class. Por ejemplo, subyacente evento adjunto Mouse.MouseDown más fácilmente se pueden controlar en cualquier UIElement utilizando MouseDown en ese UIElement en lugar de tratar con la sintaxis del evento adjunto, ya sea en XAMLXAML o código.For instance, the underlying attached event Mouse.MouseDown can more easily be handled on any given UIElement by using MouseDown on that UIElement rather than dealing with attached event syntax either in XAMLXAML or code.

Para más información sobre los eventos adjuntos en WPFWPF, vea Información general sobre eventos adjuntos.For more information about attached events in WPFWPF, see Attached Events Overview.

Nombres de evento completos en XAMLQualified Event Names in XAML

Otro uso de una sintaxis similar a la sintaxis de eventos adjuntos nombreDeTipo.nombreDeEvento pero que no es en sentido estricto un uso de eventos adjuntos se produce al adjuntar controladores para eventos enrutados que son desencadenados por elementos secundarios.Another syntax usage that resembles typename.eventname attached event syntax but is not strictly speaking an attached event usage is when you attach handlers for routed events that are raised by child elements. Los controladores se adjuntan a un elemento primario común, para aprovecharse del enrutamiento de eventos, aunque el evento enrutado pertinente no sea miembro del elemento primario común.You attach the handlers to a common parent, to take advantage of event routing, even though the common parent might not have the relevant routed event as a member. Considere este ejemplo de nuevo:Consider this example again:

<Border Height="50" Width="300" BorderBrush="Gray" BorderThickness="1">
  <StackPanel Background="LightGray" Orientation="Horizontal" Button.Click="CommonClickHandler">
    <Button Name="YesButton" Width="Auto" >Yes</Button>
    <Button Name="NoButton" Width="Auto" >No</Button>
    <Button Name="CancelButton" Width="Auto" >Cancel</Button>
  </StackPanel>
</Border>

En este caso, el agente de escucha del elemento primario donde se agrega el controlador es un StackPanel.Here, the parent element listener where the handler is added is a StackPanel. Sin embargo, agrega un controlador para un evento enrutado que se ha declarado y se producirá por la Button clase (ButtonBase realmente, pero disponible para Button a través de la herencia).However, it is adding a handler for a routed event that was declared and will be raised by the Button class (ButtonBase actually, but available to Button through inheritance). Button "posee" el evento, pero los controladores de eventos enrutados sistema permite cualquier evento enrutado que se va a asociarse a cualquier UIElement o ContentElement agente de escucha de instancia que en caso contrario, se puede adjuntar agentes de escucha para un Common Language Runtime (CLR)common language runtime (CLR) eventos.Button "owns" the event, but the routed event system permits handlers for any routed event to be attached to any UIElement or ContentElement instance listener that could otherwise attach listeners for a Common Language Runtime (CLR)common language runtime (CLR) event. El espacio de nombres xmlns predeterminado para estos nombres de atributo de evento calificados suele ser el espacio de nombres xmlns de WPFWPF predeterminado, pero también se pueden especificar espacios de nombres con prefijos para los eventos enrutados personalizados.The default xmlns namespace for these qualified event attribute names is typically the default WPFWPF xmlns namespace, but you can also specify prefixed namespaces for custom routed events. Para más información sobre xmlns, vea Espacios de nombres y asignación de espacios de nombres XAML para WPF.For more information about xmlns, see XAML Namespaces and Namespace Mapping for WPF XAML.

Eventos de entrada de WPFWPF Input Events

En la plataforma WPFWPF, con frecuencia se emplean los eventos enrutados como eventos de entrada.One frequent application of routed events within the WPFWPF platform is for input events. En WPFWPF, a los nombres de los eventos enrutados con tunelización se les antepone la palabra "Preview" por convención.In WPFWPF, tunneling routed events names are prefixed with the word "Preview" by convention. Los eventos de entrada suelen presentarse en parejas, donde uno es el evento de propagación y el otro es el evento de tunelización.Input events often come in pairs, with one being the bubbling event and the other being the tunneling event. Por ejemplo, el KeyDown eventos y PreviewKeyDown eventos tienen la misma firma, pero el primero es el evento de entrada de propagación y el último es el protocolo de túnel de entrada de evento.For example, the KeyDown event and the PreviewKeyDown event have the same signature, with the former being the bubbling input event and the latter being the tunneling input event. En ocasiones, los eventos de entrada solo tienen una versión de propagación o quizás solo una versión enrutada directa.Occasionally, input events only have a bubbling version, or perhaps only a direct routed version. En la documentación, los temas sobre eventos enrutados contienen referencias cruzadas a los temas relativos a los eventos enrutados similares con estrategias de enrutamiento alternativas, si existen dichos eventos enrutados, y las secciones de las páginas de referencia administradas clarifican la estrategia de enrutamiento de cada evento enrutado.In the documentation, routed event topics cross-reference similar routed events with alternative routing strategies if such routed events exist, and sections in the managed reference pages clarify the routing strategy of each routed event.

Los eventos de entrada de WPFWPF que se presentan en parejas se implementan de forma que una única acción del usuario desde la entrada, como presionar un botón del mouse, desencadenará los dos eventos enrutados de la pareja secuencialmente.WPFWPF input events that come in pairs are implemented so that a single user action from input, such as a mouse button press, will raise both routed events of the pair in sequence. En primer lugar, se desencadena el evento de tunelización, que viaja por su ruta.First, the tunneling event is raised and travels its route. Después se desencadena el evento de propagación y este viaja por su ruta.Then the bubbling event is raised and travels its route. Los dos eventos literalmente comparten la misma instancia de datos de evento, porque la RaiseEvent llamada al método en la clase de implementación que genera el evento de propagación realiza escuchas para los datos del evento desde el evento de túnel y vuelve a utilizar en el nuevo evento generado.The two events literally share the same event data instance, because the RaiseEvent method call in the implementing class that raises the bubbling event listens for the event data from the tunneling event and reuses it in the new raised event. Los agentes de escucha con controladores para el evento de tunelización tienen la primera oportunidad de marcar el evento enrutado como controlado (en primer lugar los controladores de clase y después los controladores de instancia).Listeners with handlers for the tunneling event have the first opportunity to mark the routed event handled (class handlers first, then instance handlers). Si un elemento a lo largo de la ruta de tunelización ha marcado el evento enrutado como controlado, los datos del evento ya controlado se envían para el evento de propagación y no se invocarán los controladores adjuntos típicos para los eventos de entrada de propagación equivalentes.If an element along the tunneling route marked the routed event as handled, the already-handled event data is sent on for the bubbling event, and typical handlers attached for the equivalent bubbling input events will not be invoked. Externamente dará la impresión de que el evento de propagación controlado ni siquiera se ha desencadenado.To outward appearances it will be as if the handled bubbling event has not even been raised. Este comportamiento de control es útil para la composición de controles, donde podría ser conveniente que fuera el control final y no sus partes compuestas el que informara de todos los eventos de entrada basados en pruebas de posicionamiento o de los eventos de entrada basados en el foco.This handling behavior is useful for control compositing, where you might want all hit-test based input events or focus-based input events to be reported by your final control, rather than its composite parts. El elemento del control final está más próximo a la raíz en la composición y, por tanto, tiene la oportunidad de controlar desde la clase el evento de tunelización en primer lugar y posiblemente "reemplazar" dicho evento enrutado por un evento más específico del control, como parte del código que respalda la clase del control.The final control element is closer to the root in the compositing, and therefore has the opportunity to class handle the tunneling event first and perhaps to "replace" that routed event with a more control-specific event, as part of the code that backs the control class.

Para ilustrar cómo funciona el procesamiento de eventos de entrada, observe el ejemplo de evento de entrada siguiente.As an illustration of how input event processing works, consider the following input event example. En la ilustración del árbol siguiente, leaf element #2 es el origen de un evento PreviewMouseDown y, después, de un evento MouseDown.In the following tree illustration, leaf element #2 is the source of both a PreviewMouseDown and then a MouseDown event.

Diagrama de enrutamiento de eventosEvent routing diagram
Propagación y tunelización de eventos de entradaInput Event Bubbling and Tunneling

El orden de procesamiento de los eventos es el siguiente:The order of event processing is as follows:

  1. PreviewMouseDown (túnel) en el elemento raíz.PreviewMouseDown (tunnel) on root element.

  2. PreviewMouseDown (túnel) en el elemento intermedio n.º 1.PreviewMouseDown (tunnel) on intermediate element #1.

  3. PreviewMouseDown (túnel) en el elemento de origen n.º 2.PreviewMouseDown (tunnel) on source element #2.

  4. MouseDown (propagación) en el elemento de origen n.º 2.MouseDown (bubble) on source element #2.

  5. MouseDown (propagación) en el elemento intermedio n.º 1.MouseDown (bubble) on intermediate element #1.

  6. MouseDown (propagación) en el elemento raíz.MouseDown (bubble) on root element.

Un delegado de controlador de eventos enrutados proporciona referencias a dos objetos: el objeto que ha desencadenado el evento y el objeto en el que se ha invocado el controlador.A routed event handler delegate provides references to two objects: the object that raised the event and the object where the handler was invoked. El objeto en el que se ha invocado el controlador es el objeto sobre el que informa el parámetro sender.The object where the handler was invoked is the object reported by the sender parameter. El objeto que se generó en primer lugar el evento se notifica mediante el Source propiedad en los datos del evento.The object where the event was first raised is reported by the Source property in the event data. Un evento enrutado aun así se genera y administra el mismo objeto, en cuyo caso sender y Source son idénticas (Esto es el caso de los pasos 3 y 4 en el evento procesar lista de ejemplo).A routed event can still be raised and handled by the same object, in which case sender and Source are identical (this is the case with Steps 3 and 4 in the event processing example list).

A causa de túnel y de propagación, los elementos primarios reciban eventos de entrada donde el Source es uno de sus secundarios de elementos.Because of tunneling and bubbling, parent elements receive input events where the Source is one of their child elements. Cuando es importante saber cuál es el elemento de origen, puede identificar el elemento de origen mediante el acceso a la Source propiedad.When it is important to know what the source element is, you can identify the source element by accessing the Source property.

Por lo general, una vez que el evento de entrada se marca Handled, además no se invocan controladores.Usually, once the input event is marked Handled, further handlers are not invoked. Lo habitual es marcar los eventos de entrada como controlados en cuanto se invoca un controlador que se ocupa del control lógico específico de la aplicación relacionado con el significado del evento de entrada.Typically, you should mark input events as handled as soon as a handler is invoked that addresses your application-specific logical handling of the meaning of the input event.

La excepción a esta instrucción general sobre Handled estado es que los controladores de eventos que se registran para omitir deliberadamente de entrada Handled todavía sería necesario invocar el estado de los datos de evento a lo largo de cualquiera de las rutas.The exception to this general statement about Handled state is that input event handlers that are registered to deliberately ignore Handled state of the event data would still be invoked along either route. Para más información, vea Eventos de vista previa o Marcar eventos enrutados como controlados y control de clases.For more information, see Preview Events or Marking Routed Events as Handled, and Class Handling.

El modelo de datos de evento compartido entre los eventos de tunelización y de propagación, y el desencadenamiento secuencial primero de los eventos de tunelización y después de los de propagación, no es un concepto que se cumpla de forma general para todos los eventos enrutados.The shared event data model between tunneling and bubbling events, and the sequential raising of first tunneling then bubbling events, is not a concept that is generally true for all routed events. Ese comportamiento se implementa específicamente según el modo en que los dispositivos de entrada de WPFWPF deciden generar y conectar los pares de eventos de entrada.That behavior is specifically implemented by how WPFWPF input devices choose to raise and connect the input event pairs. Implementar sus propios eventos de entrada es un escenario avanzado, pero también podría decidir seguir ese modelo para sus propios eventos de entrada.Implementing your own input events is an advanced scenario, but you might choose to follow that model for your own input events also.

Algunas clases eligen controlar ciertos eventos de entrada mediante clases, normalmente con la intención de volver a definir lo que significa un determinado evento de entrada controlado por el usuario dentro de ese control y de desencadenar un nuevo evento.Certain classes choose to class-handle certain input events, usually with the intent of redefining what a particular user-driven input event means within that control and raising a new event. Para más información, vea Marcar eventos enrutados como controlados y control de clases.For more information, see Marking Routed Events as Handled, and Class Handling.

Para más información sobre la entrada y cómo interactúa con los eventos en escenarios de aplicación típicos, vea Información general sobre acciones del usuario.For more information on input and how input and events interact in typical application scenarios, see Input Overview.

EventSetters y EventTriggersEventSetters and EventTriggers

En los estilos, puede incluir algunos declarado previamente XAMLXAML evento sintaxis en el marcado del control mediante el uso de un EventSetter.In styles, you can include some pre-declared XAMLXAML event handling syntax in the markup by using an EventSetter. Cuando se aplica el estilo, el controlador al que se hace referencia se agrega a la instancia que recibe el estilo.When the style is applied, the referenced handler is added to the styled instance. Puede declarar un EventSetter solo para un evento enrutado.You can declare an EventSetter only for a routed event. A continuación se muestra un ejemplo.The following is an example. Tenga en cuenta que el método b1SetColor al que se hace referencia aquí está en un archivo de código subyacente.Note that the b1SetColor method referenced here is in a code-behind file.

<StackPanel
  xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
  xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
  x:Class="SDKSample.EventOvw2"
  Name="dpanel2"
  Initialized="PrimeHandledToo"
>
  <StackPanel.Resources>
    <Style TargetType="{x:Type Button}">
      <EventSetter Event="Click" Handler="b1SetColor"/>
    </Style>
  </StackPanel.Resources>
  <Button>Click me</Button>
  <Button Name="ThisButton" Click="HandleThis">
    Raise event, handle it, use handled=true handler to get it anyway.
  </Button>
</StackPanel>

La ventaja que se obtiene aquí es que es probable que contienen una gran cantidad de información adicional que podría aplicar a cualquier botón de la aplicación, el estilo y tener la EventSetter formar parte de ese estilo promueve la reutilización de código incluso en el nivel de marcado.The advantage gained here is that the style is likely to contain a great deal of other information that could apply to any button in your application, and having the EventSetter be part of that style promotes code reuse even at the markup level. Además, un EventSetter resume los nombres de método para controladores un paso más allá del marcado de aplicación y página general.Also, an EventSetter abstracts method names for handlers one step further away from the general application and page markup.

Otra sintaxis especializada que combinan las características de animación y de evento enrutadas de WPFWPF es una EventTrigger.Another specialized syntax that combines the routed event and animation features of WPFWPF is an EventTrigger. Al igual que con EventSetter, se pueden usar solo los eventos enrutados para un EventTrigger.As with EventSetter, only routed events may be used for an EventTrigger. Normalmente, un EventTrigger se declara como parte de un estilo, pero un EventTrigger también se pueden declarar en los elementos de nivel de página como parte de la Triggers colección, o en un ControlTemplate.Typically, an EventTrigger is declared as part of a style, but an EventTrigger can also be declared on page-level elements as part of the Triggers collection, or in a ControlTemplate. Un EventTrigger le permite especificar un Storyboard que se ejecuta cada vez que un evento enrutado alcanza un elemento en su ruta que declara un EventTrigger para ese evento.An EventTrigger enables you to specify a Storyboard that runs whenever a routed event reaches an element in its route that declares an EventTrigger for that event. La ventaja de una EventTrigger sobre simplemente controlar el evento y hacer que inicie un guión gráfico existente es que un EventTrigger proporciona un mejor control sobre el guión gráfico y su comportamiento en tiempo de ejecución.The advantage of an EventTrigger over just handling the event and causing it to start an existing storyboard is that an EventTrigger provides better control over the storyboard and its run-time behavior. Para más información, vea Cómo: Utilizar desencadenadores de eventos para controlar un guión gráfico después de su inicio.For more information, see Use Event Triggers to Control a Storyboard After It Starts.

Más información sobre los eventos enrutadosMore About Routed Events

En este tema se explican principalmente los eventos enrutados desde la perspectiva de describir los conceptos básicos y proporcionar orientación sobre cómo y cuándo responder a los eventos enrutados que ya existen en los distintos elementos y controles base.This topic mainly discusses routed events from the perspective of describing the basic concepts and offering guidance on how and when to respond to the routed events that are already present in the various base elements and controls. Pero puede crear sus propios eventos enrutados en su clase personalizada junto con toda la compatibilidad necesaria, como clases y delegados de datos de evento especializados.However, you can create your own routed event on your custom class along with all the necessary support, such as specialized event data classes and delegates. El propietario del evento enrutado puede ser cualquier clase, pero deben ser generados por y controlando los eventos enrutados UIElement o ContentElement las clases derivadas para ser útil.The routed event owner can be any class, but routed events must be raised by and handled by UIElement or ContentElement derived classes in order to be useful. Para más información sobre los eventos personalizados, vea Crear un evento enrutado personalizado.For more information about custom events, see Create a Custom Routed Event.

Vea tambiénSee Also

EventManager
RoutedEvent
RoutedEventArgs
Marcar eventos enrutados como controlados y control de clasesMarking Routed Events as Handled, and Class Handling
Información general sobre acciones del usuarioInput Overview
Información general sobre comandosCommanding Overview
Propiedades de dependencia personalizadasCustom Dependency Properties
Árboles en WPFTrees in WPF
Modelos de evento débilWeak Event Patterns