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 da por supuesto que tiene conocimientos básicos del Common Language Runtime (CLR) y la programación orientada a objetos, así como el concepto de cómo las relaciones entre los elementos de WPFWPF se pueden conceptualar como un árbol.This topic assumes that you have basic knowledge of the 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, vea Tutorial: mi primera aplicación de escritorio WPF e 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: un evento enrutado es un evento CLR respaldado por una instancia de la clase RoutedEvent y lo procesa el sistema de eventos Windows Presentation Foundation (WPF)Windows Presentation Foundation (WPF).Implementation definition: A routed event is a CLR 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 sí, no y cancelarYes, No, and Cancel buttons

En este árbol de elementos simplificado, el origen de un evento de Click es uno de los elementos Button y lo Button en el que 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. Pero si no hay ningún controlador asociado al Button actúa en el evento, el evento se propagará hacia arriba hasta el Button elemento primario 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, después, más allá de 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 de eventos para este evento Click 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 encuentra un breve resumen de los escenarios que motivaron el concepto de evento enrutado y por qué un evento CLR típico no era adecuado para estos escenarios:The following is a brief summary of the scenarios that motivated the routed event concept, and why a typical CLR 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, lo 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 responda 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. Un evento enrutado crea un campo de RoutedEvent como un identificador, que proporciona una técnica de identificación de eventos sólida que no requiere 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 evento CLR respaldado por una instancia de la clase RoutedEvent y registrado con el sistema de eventos WPFWPF.A routed event is a CLR event that is backed by an instance of the RoutedEvent class and registered with the WPFWPF event system. Normalmente, la instancia de RoutedEvent obtenida del registro se conserva como public static readonly miembro de campo de la clase que registra y, por lo tanto, "posee" el 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 al evento CLR con el mismo nombre (que a veces se denomina el evento "contenedor") se logra invalidando las implementaciones de add e remove para el evento CLR.The connection to the identically named CLR event (which is sometimes termed the "wrapper" event) is accomplished by overriding the add and remove implementations for the CLR 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 respaldo y conexión de eventos enrutados es conceptualmente similar a la forma en que una propiedad de dependencia es una propiedad de CLR respaldada por la clase DependencyProperty y registrada con el sistema de propiedades WPFWPF.The routed event backing and connection mechanism is conceptually similar to how a dependency property is a CLR 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 evento enrutado de Tap personalizado, incluido el registro y la exposición del campo Identificador de RoutedEvent y las implementaciones add y remove para el evento Tap CLR.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 CLR 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 CLR estándar es la misma para agregar controladores de eventos enrutados, porque en realidad se están agregando controladores al contenedor de eventos de CLR, que tiene una implementación de eventos enrutados debajo.The XAMLXAML syntax for adding standard CLR event handlers is the same for adding routed event handlers, because you are really adding handlers to the CLR 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 evento CLR estándar, los eventos enrutados directos admiten el control de clases (el control de clases se explica en una próxima sección) y se pueden usar en EventSetter y EventTrigger.However, unlike a standard CLR 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 cualquier evento enrutado.Any UIElement or ContentElement can be an event listener for any routed event. Por lo tanto, puede usar el conjunto completo de eventos enrutados disponibles en el conjunto de API de trabajo como una "interfaz" conceptual en la que los elementos dispares de la aplicación pueden intercambiar información de eventos.Therefore, you can use the full set of routed events available throughout the working API 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 de enrutamiento, hay otras dos razones por las que cualquier evento de WPFWPF determinado podría implementarse como un evento enrutado en lugar de un evento CLR 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 CLR 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 características de estilos y plantillas como EventSetter y EventTrigger requieren que el evento al que se hace referencia sea 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 evento de Click.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 delegado de RoutedEventHandler, que es el delegado de controlador de eventos para el evento Click.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, podría controlar un evento enrutado de DragEnter.For instance, in a common input scenario, you might handle a DragEnter routed event. El controlador debe implementar el delegado de DragEventHandler.Your handler should implement the DragEventHandler delegate. Mediante el uso del delegado más específico, puede procesar el DragEventArgs en el controlador y leer la propiedad Data, 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. Los controladores de eventos enrutados siempre se pueden agregar a través de un método auxiliar AddHandler (que es el mismo método que las llamadas de respaldo existentes para add). Sin embargo, los eventos enrutados de WPFWPF existentes generalmente tienen implementaciones de respaldo de add y remove lógica que permiten agregar los controladores para los 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 del asistente: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

En el ejemplo siguiente se C# muestra la sintaxis del operador (Visual Basic tiene una sintaxis de operador ligeramente diferente debido a su control de desreferenciación):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 usa Visual Basic, también puede usar la palabra clave Handles 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 clase base de datos de evento común RoutedEventArgs.All routed events share a common event data base class, RoutedEventArgs. RoutedEventArgs define la propiedad Handled, que toma un valor booleano.RoutedEventArgs defines the Handled property, which takes a Boolean value. El propósito de la propiedad Handled es permitir que cualquier controlador de eventos a lo largo de la ruta Marque el evento enrutado como controlado, estableciendo el valor de Handled en 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 al modo en que se envía o se procesa un evento enrutado cuando se desplaza más allá 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 se true en los datos de evento de un evento enrutado, los controladores que escuchan el evento enrutado en otros elementos normalmente ya no se invocan para esa instancia de evento concreta.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. En el caso de los escenarios de controlador más comunes, el marcado de un evento como controlado estableciendo Handled en true detendrá el enrutamiento para una ruta de tunelización o una ruta de propagación, y también para cualquier evento que se controle 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" por el que los agentes de escucha pueden seguir ejecutando controladores en respuesta a los eventos enrutados donde se true Handled en los datos de 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. Solo puede utilizar el mecanismo handledEventsToo en el código o en un EventSetter:You can only use the handledEventsToo mechanism in code, or in an EventSetter:

Además del comportamiento que produce Handled estado en los eventos enrutados, el concepto de Handled tiene implicaciones en el diseño de la aplicación y en la escritura del 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 exponen los eventos enrutados.You can conceptualize Handled as being a simple protocol that is exposed by routed events. El uso exacto de este protocolo depende de usted, pero el diseño conceptual del modo en que se va a usar el valor de Handled es el siguiente: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 se encontraban antes en la ruta han elegido no registrar un controlador, o los controladores que se han registrado deciden no manipular los datos de evento y establecen Handled en 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). Los controladores del agente de escucha actual ahora tienen tres posibles cursos 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 sigue enrutando al agente de escucha siguiente, pero con Handled=true en sus datos de evento, por lo que solo los agentes de escucha de handledEventsToo 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.

Este diseño conceptual se refuerza mediante el comportamiento de enrutamiento mencionado anteriormente: es más difícil (aunque aún posible en código o estilos) adjuntar controladores para eventos enrutados que se invocan incluso si ya se ha establecido un controlador anterior a lo largo de la ruta Handled 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 sobre Handled, el control de clases de eventos enrutados y recomendaciones sobre Cuándo es adecuado marcar un evento enrutado como Handled, vea marcar eventos enrutados como controlados y control de clases.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 adjuntar un controlador de clase para un evento enrutado que sea 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, el Mouse.MouseDown de eventos adjuntos subyacente se puede controlar más fácilmente en cualquier UIElement dado mediante el uso de MouseDown en ese UIElement en lugar de tratar la sintaxis de eventos adjuntos 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>

Aquí, 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, está agregando un controlador para un evento enrutado que se declaró y lo generará la clase ButtonButtonBase (en realidad, 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 el sistema de eventos enrutados permite que los controladores de cualquier evento enrutado se adjunten a cualquier agente de escucha de la instancia de UIElement o ContentElement que, de lo contrario, podría adjuntar agentes de escucha para un evento Common Language Runtime (CLR).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) 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 evento KeyDown y el evento PreviewKeyDown tienen la misma firma, donde el primero es el evento de entrada de propagación y el último es el evento de entrada de tunelización.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 comparten literalmente la misma instancia de datos de evento, porque la llamada al método RaiseEvent en la clase de implementación que genera el evento de propagación realiza escuchas para los datos de evento desde el evento de tunelización y lo 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 de árbol siguiente, leaf element #2 es el origen de un PreviewMouseDown y, a continuación, 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 eventos

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. La propiedad Source de los datos de evento detecta el objeto en el que se generó el evento por primera vez.The object where the event was first raised is reported by the Source property in the event data. Un evento enrutado todavía puede ser generado y controlado por el mismo objeto, en cuyo caso sender y Source son idénticos (este es el caso de los pasos 3 y 4 en la lista ejemplo de procesamiento de eventos).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).

Debido a la tunelización y la propagación, los elementos primarios reciben eventos de entrada en los que el Source es uno de sus elementos secundarios.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 propiedad Source.When it is important to know what the source element is, you can identify the source element by accessing the Source property.

Normalmente, una vez que el evento de entrada se marca como Handled, no se invocan más 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 el estado de Handled es que los controladores de eventos de entrada que se registran para omitir deliberadamente el estado Handled de los datos de evento se pueden invocar a lo largo de cualquier ruta.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 alguna sintaxis de control de eventos XAMLXAML declarada previamente en el marcado 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. Solo se puede declarar un EventSetter 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 el estilo contenga una gran cantidad de información que se pueda aplicar a cualquier botón de la aplicación y que el EventSetter forme parte de ese estilo promueva 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 abstrae los nombres de método para los controladores un paso más allá de la aplicación general y el marcado de página.Also, an EventSetter abstracts method names for handlers one step further away from the general application and page markup.

Otra sintaxis especializada que combina las características de animación y eventos enrutados de WPFWPF es una EventTrigger.Another specialized syntax that combines the routed event and animation features of WPFWPF is an EventTrigger. Como con EventSetter, solo se pueden usar 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 también se puede declarar un EventTrigger en elementos de nivel de página como parte de la colección de Triggers 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. Una EventTrigger 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 un EventTrigger sobre simplemente controlar el evento y hacer que se inicie un guion 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 los eventos enrutados se deben generar y controlar mediante UIElement o ContentElement clases derivadas para ser útiles.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