Vue d'ensemble des événements routésRouted Events Overview

Cette rubrique explique le concept d’événements routés dans 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). Elle définit les termes utilisés pour les événements routés, elle explique comment ces événements sont routés via une arborescence d’éléments, elle résume la façon dont sont gérés les événements routés et elle explique comment créer ses propres événements routés personnalisés.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.

PrérequisPrerequisites

Cette rubrique suppose que vous avez une connaissance de base des Common Language Runtime (CLR) et de la programmation orientée objet, ainsi que le concept de la manière dont WPFWPF les relations entre les éléments peuvent être conceptuelles comme une arborescence.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. Pour pouvoir suivre les exemples de cette rubrique, vous devez également connaître le langage XAML (eXtensible Application Markup Language)Extensible Application Markup Language (XAML) et savoir écrire des applications ou des pages WPFWPF rudimentaires.In order to follow the examples in this topic, you should also understand langage XAML (eXtensible Application Markup Language)Extensible Application Markup Language (XAML) and know how to write very basic WPFWPF applications or pages. Pour plus d’informations, consultez Procédure pas à pas : Ma première application de bureau WPF et vue d’ensemble du langage XAML (WPF).For more information, see Walkthrough: My first WPF desktop application and XAML Overview (WPF).

Qu’est-ce qu’un événement routé ?What Is a Routed Event?

Les événements routés peuvent être compris d’un point de vue fonctionnel et du point de vue de l’implémentation.You can think about routed events either from a functional or implementation perspective. Les deux définitions sont présentées ici pour une meilleure compréhension du concept.Both definitions are presented here, because some people find one or the other definition more useful.

Définition fonctionnelle: Un événement routé est un type d’événement qui peut appeler des gestionnaires sur plusieurs écouteurs dans une arborescence d’éléments, plutôt que sur l’objet qui a déclenché l’événement.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.

Définition d’implémentation: Un événement routé est un événement CLR qui est stocké par une instance de la RoutedEvent classe et qui est traité par le Windows Presentation Foundation (WPF)Windows Presentation Foundation (WPF) système d’événements.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.

Une application WPFWPF type contient de nombreux éléments.A typical WPFWPF application contains many elements. Qu’ils soient créés dans le code ou déclarés dans XAMLXAML, ces éléments sont reliés entre eux au sein d’une arborescence d’éléments.Whether created in code or declared in XAMLXAML, these elements exist in an element tree relationship to each other. L’itinéraire de l’événement peut prendre deux directions différentes, en fonction de la définition de l’événement. Toutefois, l’itinéraire part en général de l’élément source et se propage ensuite vers le haut dans l’arborescence d’éléments, jusqu’à atteindre la racine de l’arborescence d’éléments (en général, une page ou une fenêtre).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). Le concept de propagation peut vous être familier si vous avez déjà travaillé avec le modèle d’objet DHTML.This bubbling concept might be familiar to you if you have worked with the DHTML object model previously.

Prenons l’arborescence d’éléments suivante :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>

Cette arborescence d’éléments produit ce qui suit :This element tree produces something like the following:

Boutons Oui, Non et AnnulerYes, No, and Cancel buttons

Dans cette arborescence d’éléments simplifiée, la source Click d’un événement est l' Button un des éléments et Button l’élément sur lequel l’utilisateur a cliqué est le premier élément qui a la possibilité de gérer l’événement.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. Toutefois, si aucun gestionnaire attaché à Button n’agit sur l’événement, l’événement se propage vers le Button haut jusqu’au parent dans l’arborescence d’éléments, qui est StackPanelle.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. Potentiellement, l’événement se propage Borderà, puis au-delà de la racine de la page de l’arborescence d’éléments (non affiché).Potentially, the event bubbles to Border, and then beyond to the page root of the element tree (not shown).

En d’autres termes, l’itinéraire d’événement Click pour cet événement est le suivant:In other words, the event route for this Click event is:

Button-->StackPanel-->Border-->...Button-->StackPanel-->Border-->...

Scénarios de premier niveau pour les événements routésTop-level Scenarios for Routed Events

Voici un bref résumé des scénarios qui ont motivé le concept d’événement routé et pourquoi un événement CLR typique n’était pas adapté à ces scénarios: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:

Composition et encapsulation des contrôles: Différents contrôles dans WPFWPF ont un modèle de contenu riche.Control composition and encapsulation: Various controls in WPFWPF have a rich content model. Par exemple, vous pouvez placer une image à l’intérieur Buttond’un, ce qui étend efficacement l’arborescence d’éléments visuels du bouton.For example, you can place an image inside of a Button, which effectively extends the visual tree of the button. Toutefois, l’image ajoutée ne doit pas rompre le comportement de test d’atteinte qui provoque la réponse d' Click un bouton à un de son contenu, même si l’utilisateur clique sur des pixels qui font techniquement partie de l’image.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.

Points d’attachement du gestionnaire singuliers: Dans Windows FormsWindows Forms, vous devez attacher le même gestionnaire plusieurs fois pour traiter les événements qui peuvent être déclenchés à partir de plusieurs éléments.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. Les événements routés vous permettent d’attacher ce gestionnaire une seule fois, comme dans l’exemple précédent, et d’utiliser la logique du gestionnaire pour déterminer d’où provient l’événement, si nécessaire.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. Par exemple, ceci pourrait être le gestionnaire du XAMLXAML présenté précédemment :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

Gestion des classes: Les événements routés autorisent un gestionnaire statique qui est défini par la classe.Class handling: Routed events permit a static handler that is defined by the class. Ce gestionnaire de classe a l’opportunité de gérer un événement avant les autres gestionnaires d’instance attachés.This class handler has the opportunity to handle an event before any attached instance handlers can.

Référencement d’un événement sans réflexion: Certaines techniques de code et de balisage requièrent un moyen d’identifier un événement spécifique.Referencing an event without reflection: Certain code and markup techniques require a way to identify a specific event. Un événement routé crée un RoutedEvent champ en tant qu’identificateur, ce qui fournit une technique d’identification d’événement robuste qui ne nécessite pas de réflexion statique ou au moment de l’exécution.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.

Implémentation des événements routésHow Routed Events Are Implemented

Un événement routé est un événement CLR qui est stocké par une instance de la RoutedEvent classe et inscrit auprès du WPFWPF système d’événements.A routed event is a CLR event that is backed by an instance of the RoutedEvent class and registered with the WPFWPF event system. L' RoutedEvent instance obtenue à partir de l’inscription est généralement public conservée static readonly en tant que membre de champ de la classe qui inscrit et, par conséquent, «possède» l’événement routé.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 connexion à l’événement CLR portant un nom identique (qui est parfois appelé événement «Wrapper») s’effectue en substituant les add implémentations et remove pour l’événement 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. En règle générale, add et remove sont conservés comme des valeurs implicites par défaut qui utilisent la syntaxe d’événement spécifique au langage pour ajouter et supprimer des gestionnaires de cet événement.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. Le mécanisme de connexion et de stockage des événements routés est conceptuellement similaire à la façon dont une propriété de dépendance est une propriété CLR qui DependencyProperty est stockée par la WPFWPF classe et inscrite auprès du système de propriétés.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.

L’exemple suivant illustre la déclaration d’un événement Tap routé personnalisé, y compris l’inscription et l’exposition RoutedEvent du champ d' add identificateur et des implémentations et remove pour l' Tap événement 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

Gestionnaires d’événements routés et XAMLRouted Event Handlers and XAML

Pour ajouter un gestionnaire à un événement à l’aide de XAMLXAML, déclarez le nom de l’événement en tant qu’attribut sur l’élément qui joue le rôle d’écouteur d’événements.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. La valeur de l’attribut est le nom de votre méthode de gestionnaire implémentée, qui doit se trouver dans la classe partielle du fichier code-behind.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 XAMLXAML syntaxe pour l’ajout de gestionnaires d’événements CLR standard est la même pour l’ajout de gestionnaires d’événements routés, car vous ajoutez véritablement des gestionnaires au wrapper d’événement CLR, qui a une implémentation d’événement routé sous-jacente.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. Pour plus d’informations sur l’ajout de gestionnaires d’événements dans XAMLXAML, consultez Vue d’ensemble du langage XAML (WPF).For more information about adding event handlers in XAMLXAML, see XAML Overview (WPF).

Stratégies de routageRouting Strategies

Les événements routés utilisent l’une des trois stratégies de routage suivantes :Routed events use one of three routing strategies:

  • Propagation Les gestionnaires d’événements sur la source d’événements sont appelés.Bubbling: Event handlers on the event source are invoked. L’événement routé est acheminé ensuite vers des éléments parents successifs jusqu’à atteindre la racine de l’arborescence d’éléments.The routed event then routes to successive parent elements until reaching the element tree root. La plupart des événements routés utilisent la stratégie de routage par propagation.Most routed events use the bubbling routing strategy. Les événements routés par propagation sont généralement utilisés pour signaler des entrées ou des changements d’état à partir de contrôles distincts ou d’autres éléments d’interface utilisateur.Bubbling routed events are generally used to report input or state changes from distinct controls or other UI elements.

  • Directe Seul l’élément source lui-même a la possibilité d’appeler des gestionnaires en réponse.Direct: Only the source element itself is given the opportunity to invoke handlers in response. Cela s’apparente au « routage » que Windows FormsWindows Forms utilise pour les événements.This is analogous to the "routing" that Windows FormsWindows Forms uses for events. Toutefois, contrairement à un événement CLR standard, les événements routés directs prennent en charge la gestion de classe (la gestion de classe est expliquée dans EventSetter une EventTriggersection à venir) et peut être utilisée par et.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.

  • Tunneling Initialement, les gestionnaires d’événements au niveau de la racine de l’arborescence d’éléments sont appelés.Tunneling: Initially, event handlers at the element tree root are invoked. L’événement routé passe ensuite par des éléments enfants successifs pour aller vers l’élément de nœud correspondant à la source de l’événement routé (l’élément qui a déclenché l’événement routé).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). Les événements routés de tunneling sont souvent utilisés ou gérés dans le cadre de la composition d’un contrôle, de telle manière que les événements issus de parties composites peuvent être délibérément supprimés ou remplacés par des événements spécifiques au contrôle complet.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. Les événements d’entrée fournis dans WPFWPF sont souvent implémentés comme une paire tunneling/propagation.Input events provided in WPFWPF often come implemented as a tunneling/bubbling pair. Les événements de tunneling sont parfois appelés événements Preview en raison d’une convention de nommage utilisée pour les paires.Tunneling events are also sometimes referred to as Preview events, because of a naming convention that is used for the pairs.

Pourquoi utiliser des événements routés ?Why Use Routed Events?

En tant que développeur d’applications, il n’est pas toujours nécessaire de savoir que l’événement que vous gérez est implémenté comme un événement routé.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. Les événements routés présentent un comportement particulier, mais ce comportement est en grande partie invisible si vous gérez l’événement sur l’élément à partir duquel il a été déclenché.Routed events have special behavior, but that behavior is largely invisible if you are handling an event on the element where it is raised.

Les événements routés deviennent puissants lorsqu’ils sont utilisés dans l’un des scénarios suivants : définition de gestionnaires communs au niveau d’une racine commune, composition de votre propre contrôle ou définition de votre propre classe de contrôle personnalisé.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.

Les écouteurs et les sources d’événements routés n’ont pas besoin de partager un événement commun dans leur hiérarchie.Routed event listeners and routed event sources do not need to share a common event in their hierarchy. Tout UIElement ouContentElement peut être un écouteur d’événements pour n’importe quel événement routé.Any UIElement or ContentElement can be an event listener for any routed event. Par conséquent, vous pouvez utiliser l’ensemble des événements routés disponibles sur l’ensemble de l’API de travail comme une «interface» conceptuelle qui permet aux éléments disparates de l’application d’échanger des informations sur les événements.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. Ce concept d’« interface » pour les événements routés s’applique plus particulièrement aux événements d’entrée.This "interface" concept for routed events is particularly applicable for input events.

Les événements routés peuvent également servir à communiquer au sein de l’arborescence d’éléments, car les données de l’événement sont propagées vers chaque élément rencontré sur l’itinéraire.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. Si un élément change les données d’événement, ce changement est disponible pour l’élément suivant dans l’itinéraire.One element could change something in the event data, and that change would be available to the next element in the route.

Outre l’aspect de routage, il existe deux autres raisons pour lesquelles un WPFWPF événement donné peut être implémenté comme un événement routé au lieu d’un événement CLR standard.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 vous implémentez vos propres événements, vous pouvez également prendre en compte ces principes :If you are implementing your own events, you might also consider these principles:

  • Certaines WPFWPF fonctionnalités de création de styles et de EventSetter modèles EventTrigger , telles que et, exigent que l’événement référencé soit un événement routé.Certain WPFWPF styling and templating features such as EventSetter and EventTrigger require the referenced event to be a routed event. Il s’agit du scénario d’identificateur d’événement mentionné précédemment.This is the event identifier scenario mentioned earlier.

  • Les événements routés prennent en charge un mécanisme de gestion de classe par lequel la classe peut spécifier des méthodes statiques qui ont l’opportunité de gérer des événements routés avant que les gestionnaires d’instance inscrits puissent y accéder.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. Ceci est très utile pour la conception de contrôles, car la classe peut appliquer des comportements de classe pilotés par les événements qui ne peuvent pas être supprimés par inadvertance lorsque vous gérez un événement sur une instance.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.

Toutes les considérations ci-dessus sont abordées dans une autre section de cette rubrique.Each of the above considerations is discussed in a separate section of this topic.

Ajout et implémentation d’un gestionnaire d’événements pour un événement routéAdding and Implementing an Event Handler for a Routed Event

Pour ajouter un gestionnaire d’événements dans XAMLXAML, ajoutez le nom de l’événement à un élément en tant qu’attribut, et définissez la valeur de l’attribut sur le nom du gestionnaire d’événements qui implémente un délégué, comme dans l’exemple suivant.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>

b1SetColornom du gestionnaire implémenté qui contient le code qui gère l' Click événement.b1SetColor is the name of the implemented handler that contains the code that handles the Click event. b1SetColordoit avoir la même signature que le RoutedEventHandler délégué, qui est le délégué de gestionnaire d’événements Click pour l’événement.b1SetColor must have the same signature as the RoutedEventHandler delegate, which is the event handler delegate for the Click event. Le premier paramètre de tous les délégués de gestionnaires d’événements routés spécifie l’élément auquel le gestionnaire d’événements est ajouté, et le deuxième paramètre spécifie les données de l’événement.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

RoutedEventHandlerest le délégué de gestionnaire d’événements routés de base.RoutedEventHandler is the basic routed event handler delegate. Pour les événements routés qui conviennent spécialement à certains contrôles ou scénarios, les délégués à utiliser avec les gestionnaires d’événements routés peuvent également devenir plus spécialisés, de manière à pouvoir transmettre des données d’événement spécialisées.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. Par exemple, dans un scénario d’entrée courant, vous pouvez gérer DragEnter un événement routé.For instance, in a common input scenario, you might handle a DragEnter routed event. Votre gestionnaire doit implémenter DragEventHandler le délégué.Your handler should implement the DragEventHandler delegate. En utilisant le délégué le plus spécifique, vous pouvez traiter DragEventArgs le dans le gestionnaire et lire Data la propriété, qui contient la charge utile du presse-papiers de l’opération glisser.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.

Pour un exemple complet montrant comment ajouter un gestionnaire d’événements à un élément à l’aide de XAMLXAML, consultez Gérer un événement routé.For a complete example of how to add an event handler to an element using XAMLXAML, see Handle a Routed Event.

L’ajout d’un gestionnaire pour un événement routé dans une application créée dans du code est une opération simple.Adding a handler for a routed event in an application that is created in code is straightforward. Les gestionnaires d’événements routés peuvent toujours être ajoutés par le biais d' AddHandler une méthode d’assistance (qui est la même méthode que celle qui addest appelée par le stockage existant). Toutefois, les événements routés WPFWPF existants disposent généralement d’implémentations de stockage de logique add et remove qui permettent aux gestionnaires d’événements routés d’être ajoutés à une syntaxe d’événement spécifique au langage, qui est une syntaxe plus intuitive que celle de la méthode d’assistance.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. Voici un exemple d’utilisation de la méthode d’assistance :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

L’exemple suivant illustre la C# syntaxe de l’opérateur (Visual Basic a une syntaxe d’opérateur légèrement différente en raison de la gestion du déréférencement):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

Pour obtenir un exemple montrant comment ajouter un gestionnaire d’événements dans le code, consultez Ajouter un gestionnaire d’événements à l’aide de code.For an example of how to add an event handler in code, see Add an Event Handler Using Code.

Si vous utilisez Visual Basic, vous pouvez également utiliser le Handles mot clé pour ajouter des gestionnaires dans le cadre des déclarations de gestionnaire.If you are using Visual Basic, you can also use the Handles keyword to add handlers as part of the handler declarations. Pour plus d’informations, consultez Gestion des événements Visual Basic et WPF.For more information, see Visual Basic and WPF Event Handling.

Concept du HandledThe Concept of Handled

Tous les événements routés partagent une classe de base de données RoutedEventArgsd’événements commune,.All routed events share a common event data base class, RoutedEventArgs. RoutedEventArgsdéfinit la Handled propriété, qui prend une valeur booléenne.RoutedEventArgs defines the Handled property, which takes a Boolean value. L’objectif de la Handled propriété est de permettre à n’importe quel gestionnaire d’événements sur l’itinéraire de marquer l’événement routé comme géré, en Handled affectant trueà la valeur.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. Après avoir été traitées par le gestionnaire au niveau d’un élément de l’itinéraire, les données d’événement partagées sont à nouveau signalées à chaque écouteur se trouvant sur l’itinéraire.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.

La valeur de Handled affecte la façon dont un événement routé est signalé ou traité à mesure qu’il traverse l’itinéraire.The value of Handled affects how a routed event is reported or processed as it travels further along the route. Si Handled se true trouve dans les données d’événement pour un événement routé, les gestionnaires qui écoutent cet événement routé sur d’autres éléments ne sont généralement plus appelés pour cette instance d’événement particulière.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. Ceci est vrai à la fois pour les gestionnaires attachés dans XAMLXAML et pour ceux ajoutés par des syntaxes d’attachement de gestionnaire d’événements spécifiques au langage, comme += ou 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. Pour les scénarios de gestionnaires les plus courants, le fait de marquer Handled un true événement comme géré en affectant à la valeur «arrêter» le routage pour un itinéraire de tunneling ou un itinéraire de propagation, ainsi que pour tout événement géré à un point de l’itinéraire par un gestionnaire de classe.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.

Toutefois, il existe un mécanisme «handledEventsToo» dans lequel les écouteurs peuvent toujours exécuter des gestionnaires en réponse à des événements routés trueHandled se trouve dans les données d’événement.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. En d’autres termes, l’itinéraire d’événement n’est pas réellement arrêté quand les données d’événement sont marquées comme gérées.In other words, the event route is not truly stopped by marking the event data as handled. Vous pouvez uniquement utiliser le mécanisme handledEventsToo dans le code ou dans un EventSetter:You can only use the handledEventsToo mechanism in code, or in an EventSetter:

En plus du comportement que Handled l’État produit dans les événements routés, le concept de a des Handled implications quant à la façon dont vous devez concevoir votre application et écrire le code du gestionnaire d’événements.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. Vous pouvez conceptualiser Handled comme un protocole simple exposé par les événements routés.You can conceptualize Handled as being a simple protocol that is exposed by routed events. La façon dont vous utilisez ce protocole dépend de vous, mais la conception conceptuelle de la façon dont la Handled valeur de est destinée à être utilisée est la suivante: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 événement routé est marqué comme géré, il n’a pas besoin d’être géré de nouveau par d’autres éléments sur l’itinéraire.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 événement routé n’est pas marqué comme géré, alors les autres écouteurs qui étaient antérieurs le long de l’itinéraire ont choisi de ne pas inscrire de gestionnaire, ou les gestionnaires qui ont été inscrits choisissent de ne pas manipuler les Handled données trued’événement et de définir sur.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. Il est également possible que l’écouteur actuel soit le premier de l’itinéraire. Les gestionnaires de l’écouteur actuel ont maintenant trois possibilités :(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:

    • Ne rien faire. L’événement reste non géré et l’événement est dirigé vers l’écouteur suivant.Take no action at all; the event remains unhandled, and the event routes to the next listener.

    • Exécuter du code en réponse à l’événement, mais décider que l’action entreprise n’était pas suffisamment importante pour garantir le marquage de l’événement comme géré.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. L’événement est dirigé vers l’écouteur suivant.The event routes to the next listener.

    • Exécuter du code en réponse à l’événement.Execute code in response to the event. Marquer l’événement comme géré dans les données d’événement passées au gestionnaire, car l’action entreprise est jugée suffisamment importante pour garantir le marquage de l’événement comme géré.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. L’événement est encore routé vers l’écouteur suivant, mais Handled avec = true dans ses données d’événement, handledEventsToo seuls les écouteurs ont la possibilité d’appeler d’autres gestionnaires.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.

Cette conception conceptuelle est renforcée par le comportement de routage mentionné précédemment: il est plus difficile (bien que possible dans le code ou les styles) d’attacher des gestionnaires pour les événements routés qui sont appelés même si un gestionnaire précédent le long de l’itinéraire a déjà été défini 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.

Pour plus d’informations Handledsur la gestion des classes des événements routés et des recommandations sur le moment où il convient de marquer un événement Handledrouté comme, consultez marquage des événements routés comme gérés et gestion de classe.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.

Dans les applications, il est assez courant de gérer un événement routé par propagation sur l’objet qui l’a déclenché, sans se soucier des caractéristiques de routage de l’événement.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. Toutefois, il est recommandé de toujours marquer l’événement routé comme géré (handled) dans les données d’événement, afin d’éviter des effets secondaires si un élément situé plus haut dans l’arborescence d’éléments comportait également un gestionnaire attaché pour le même événement routé.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.

Gestionnaires de classeClass Handlers

Si vous définissez une classe qui dérive d’une certaine manière de DependencyObject, vous pouvez également définir et attacher un gestionnaire de classe pour un événement routé qui est un membre d’événement déclaré ou hérité de votre classe.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. Les gestionnaires de classe sont appelés avant les gestionnaires d’écouteur d’instance qui sont attachés à une instance de cette classe, chaque fois qu’un événement routé atteint une instance d’élément sur son itinéraire.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.

Certains contrôles WPFWPF disposent d’une gestion de classe inhérente pour certains événements routés.Some WPFWPF controls have inherent class handling for certain routed events. Ceci peut donner l’apparence que l’événement routé n’a même pas été déclenché, alors qu’en réalité il est géré par la classe, et peut encore potentiellement être géré par vos gestionnaires d’instance si vous utilisez certaines techniques.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. En outre, plusieurs classes et contrôles de base exposent des méthodes virtuelles qui peuvent être utilisées pour substituer le comportement de gestion de classe.Also, many base classes and controls expose virtual methods that can be used to override class handling behavior. Pour plus d’informations sur la façon de contourner la gestion de classe et sur la définition de votre propre gestion de classe dans une classe personnalisée, consultez Marquage des événements routés comme gérés et gestion de classe.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.

Événements attachés dans WPFAttached Events in WPF

Le langage XAMLXAML définit également un type particulier d’événement appelé événement attaché.The XAMLXAML language also defines a special type of event called an attached event. Un événement attaché permet d’ajouter le gestionnaire d’un événement particulier à un élément arbitraire.An attached event enables you to add a handler for a particular event to an arbitrary element. L’élément qui gère l’événement n’a pas besoin de définir ou d’hériter de l’événement attaché. En outre, ni l’objet qui déclenche potentiellement l’événement, ni l’instance de gestion de destination ne doivent définir ou « posséder » cet événement comme un membre de classe.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.

Le système d’entrée WPFWPF utilise largement les événements attachés.The WPFWPF input system uses attached events extensively. Cependant, presque tous ces événements attachés sont transférés via des éléments de base.However, nearly all of these attached events are forwarded through base elements. Les événements d’entrée apparaissent alors comme des événements routés non attachés équivalents qui sont membres de la classe d’élément de base.The input events then appear as equivalent non-attached routed events that are members of the base element class. Par exemple Mouse.MouseDown , l’événement attaché sous-jacent peut être géré plus facilement sur tout donné MouseDown UIElement en utilisant UIElement sur, plutôt que de gérer la syntaxe de l' XAMLXAML événement attaché dans ou dans le code.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.

Pour plus d’informations sur les événements attachés dans WPFWPF, consultez Vue d’ensemble des événements attachés.For more information about attached events in WPFWPF, see Attached Events Overview.

Noms qualifiés d’événements en XAMLQualified Event Names in XAML

Une autre utilisation de la syntaxe qui ressemble à la syntaxe d’événement attaché typename.eventname, mais qui n’est pas à proprement parler une utilisation d’événement attaché est lorsque vous attachez des gestionnaires pour les événements routés qui sont déclenchés par des éléments enfants.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. Vous attachez les gestionnaires à un parent commun pour tirer parti du routage d’événements, même si le parent commun ne dispose pas de l’événement routé nécessaire comme membre.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. Regardons de nouveau cet exemple :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>

Ici, l’écouteur d’élément parent où le gestionnaire est ajouté est StackPanelun.Here, the parent element listener where the handler is added is a StackPanel. Toutefois, il ajoute un gestionnaire pour un événement routé qui a été déclaré et sera déclenché par la classe ( Button ButtonBase en fait, mais disponible pour par Button le biais de l’héritage).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). Buttonl’événement «est propriétaire», mais le système d’événement routé autorise les gestionnaires pour tout événement routé à être attaché à n' UIElement importe ContentElement quel écouteur d’instance ou qui pourrait attacher des écouteurs pour un événement 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. L’espace de noms xmlns par défaut pour ces noms d’attributs d’événement qualifiés est généralement l’espace de noms xmlns WPFWPF par défaut. Cependant, vous pouvez spécifier des espaces de noms avec préfixe pour les événements routés personnalisés.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. Pour plus d’informations sur xmlns, consultez Espaces de noms XAML et mappage d’espace de noms pour XAML WPF.For more information about xmlns, see XAML Namespaces and Namespace Mapping for WPF XAML.

Événements d’entrée WPFWPF Input Events

Les événements routés sont fréquemment utilisés dans la plateforme WPFWPF pour les événements d’entrée.One frequent application of routed events within the WPFWPF platform is for input events. Par convention, dans WPFWPF, les noms d’événements routés par tunneling comprennent le préfixe « Preview ».In WPFWPF, tunneling routed events names are prefixed with the word "Preview" by convention. Les événements d’entrée vont souvent par paires, l’un étant l’événement de propagation et l’autre, l’événement de tunneling.Input events often come in pairs, with one being the bubbling event and the other being the tunneling event. Par exemple, l' KeyDown événement et l' PreviewKeyDown événement ont la même signature, le premier étant l’événement d’entrée de propagation et le dernier étant l’événement d’entrée de tunneling.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. Parfois, les événements d’entrée ont uniquement une version par propagation, ou uniquement une version à routage direct.Occasionally, input events only have a bubbling version, or perhaps only a direct routed version. Dans la documentation, les rubriques relatives aux événements routés font référence à des événements routés similaires avec d’autres stratégies de routage, et les sections des pages concernant les références managées expliquent plus en détail la stratégie de routage de chaque événement routé.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.

Les événements d’entrée WPFWPF fournis par paires sont implémentés de telle sorte qu’une seule opération d’entrée, comme un clic de souris, déclenche les deux événements de la paire l’un après l’autre.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. Tout d’abord, l’événement de tunneling est déclenché et suit son itinéraire.First, the tunneling event is raised and travels its route. Ensuite, l’événement de propagation est déclenché et suit son itinéraire.Then the bubbling event is raised and travels its route. Les deux événements partagent littéralement la même instance de données d’événement, RaiseEvent car l’appel de méthode dans la classe d’implémentation qui déclenche l’événement de propagation écoute les données d’événement à partir de l’événement de tunneling et les réutilise dans le nouvel événement déclenché.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. Les écouteurs qui comportent des gestionnaires pour l’événement de tunneling sont les premiers à pouvoir marquer l’événement routé comme géré (d’abord les gestionnaires de classe, ensuite les gestionnaires d’instance).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 élément a marqué l’événement routé comme géré sur l’itinéraire de tunneling, les données d’événement déjà gérées sont envoyées à l’événement de propagation, et les gestionnaires standard attachés pour les événements d’entrée de propagation équivalents ne sont pas appelés.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. Vu de l’extérieur, il peut sembler que l’événement de propagation géré n’a pas encore été déclenché.To outward appearances it will be as if the handled bubbling event has not even been raised. Ce comportement de gestion est utile pour la composition de contrôles, où vous pouvez souhaiter que tous les événements d’entrée basés sur les tests d’atteinte ou le focus soient signalés par votre dernier contrôle, plutôt que par ses parties composites.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. Le dernier élément de contrôle est plus proche de la racine dans la composition et peut donc être le premier à gérer la classe de l’événement de tunneling et éventuellement à « remplacer » l’événement routé par un événement plus spécifique au contrôle dans le code qui stocke la classe de contrôle.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.

En guise d’illustration du traitement des événements d’entrée, prenez l’exemple d’événement d’entrée suivant.As an illustration of how input event processing works, consider the following input event example. Dans l’illustration suivante, leaf element #2 est la source d’un PreviewMouseDown événement, puis d’un MouseDown événement:In the following tree illustration, leaf element #2 is the source of both a PreviewMouseDown and then a MouseDown event:

Diagramme de routage d'événements

L’ordre de traitement des événements est le suivant :The order of event processing is as follows:

  1. PreviewMouseDown (tunneling) sur l’élément racine.PreviewMouseDown (tunnel) on root element.

  2. PreviewMouseDown (tunneling) sur l’élément intermédiaire numéro 1.PreviewMouseDown (tunnel) on intermediate element #1.

  3. PreviewMouseDown (tunneling) sur l’élément source numéro 2.PreviewMouseDown (tunnel) on source element #2.

  4. MouseDown (propagation) sur l’élément source numéro 2.MouseDown (bubble) on source element #2.

  5. MouseDown (propagation) sur l’élément intermédiaire numéro 1.MouseDown (bubble) on intermediate element #1.

  6. MouseDown (propagation) sur l’élément racine.MouseDown (bubble) on root element.

Un délégué de gestionnaire d’événements routés fournit des références à deux objets : l’objet qui a déclenché l’événement et l’objet à partir duquel le gestionnaire a été appelé.A routed event handler delegate provides references to two objects: the object that raised the event and the object where the handler was invoked. L’objet à partir duquel le gestionnaire a été appelé est celui signalé par le paramètre sender.The object where the handler was invoked is the object reported by the sender parameter. L’objet dans lequel l’événement a été déclenché pour la première Source fois est signalé par la propriété dans les données d’événement.The object where the event was first raised is reported by the Source property in the event data. Un événement routé peut toujours être déclenché et géré par le même objet, auquel cas sender et Source sont identiques (c’est le cas avec les étapes 3 et 4 dans la liste d’exemples de traitement des événements).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).

En raison du tunneling et de la propagation, les éléments parents reçoivent des Source événements d’entrée où est l’un de leurs éléments enfants.Because of tunneling and bubbling, parent elements receive input events where the Source is one of their child elements. Lorsqu’il est important de connaître l’élément source, vous pouvez identifier l’élément source en accédant à la Source propriété.When it is important to know what the source element is, you can identify the source element by accessing the Source property.

En général, une fois que l’événement Handledd’entrée est marqué, les gestionnaires supplémentaires ne sont pas appelés.Usually, once the input event is marked Handled, further handlers are not invoked. En outre, vous devez marquer les événements d’entrée comme gérés dès qu’un gestionnaire est appelé pour traiter votre gestion logique (et spécifique à l’application) de la signification de l’événement d’entrée.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.

L’exception à cette déclaration générale sur Handled l’État est que les gestionnaires d’événements d’entrée inscrits pour ignorer Handled délibérément l’état des données d’événement seraient toujours appelés le long de l’itinéraire.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. Pour plus d’informations, consultez Événements Preview ou Marquage des événements routés comme gérés et gestion de classe.For more information, see Preview Events or Marking Routed Events as Handled, and Class Handling.

Le modèle de données d’événement partagé entre les événements de tunneling et de propagation, avec le déclenchement séquentiel de l’événement de tunneling puis de l’événement de propagation, est un concept qui n’est pas valable pour tous les événements routés.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. Ce comportement est implémenté selon la manière dont les périphériques d’entrée WPFWPF choisissent de déclencher et de connecter les paires d’événements d’entrée.That behavior is specifically implemented by how WPFWPF input devices choose to raise and connect the input event pairs. L’implémentation de vos propres événements d’entrée est un scénario avancé. Toutefois, vous pouvez choisir de suivre ce modèle pour vos propres événements d’entrée.Implementing your own input events is an advanced scenario, but you might choose to follow that model for your own input events also.

Certaines classes choisissent de gérer la classe de certains événements d’entrée, généralement dans le but de redéfinir la signification d’un événement d’entrée piloté par l’utilisateur dans le contrôle, et dans le but de déclencher un nouvel événement.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. Pour plus d’informations, consultez Marquage des événements routés comme gérés et gestion de classe.For more information, see Marking Routed Events as Handled, and Class Handling.

Pour plus d’informations sur les entrées et la façon dont elles interagissent avec les événements dans des scénarios d’application standard, consultez Vue d’ensemble des entrées.For more information on input and how input and events interact in typical application scenarios, see Input Overview.

EventSetters et EventTriggersEventSetters and EventTriggers

Dans les styles, vous pouvez inclure une syntaxe de XAMLXAML gestion des événements pré-déclarés dans le EventSetterbalisage à l’aide d’un.In styles, you can include some pre-declared XAMLXAML event handling syntax in the markup by using an EventSetter. Lorsque le style est appliqué, le gestionnaire référencé est ajouté à l’instance à laquelle est appliqué le style.When the style is applied, the referenced handler is added to the styled instance. Vous pouvez déclarer un EventSetter uniquement pour un événement routé.You can declare an EventSetter only for a routed event. Voici un exemple.The following is an example. Notez que la méthode b1SetColor référencée ici se trouve dans un fichier code-behind.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>

L’avantage acquis ici est que le style est susceptible de contenir une grande quantité d’autres informations qui peuvent s’appliquer à n’importe quel bouton de votre application et EventSetter que le fait de faire partie de ce style favorise la réutilisation du code, même au niveau du balisage.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. En outre, EventSetter les noms de méthode abstraits pour les gestionnaires sont encore plus éloignés de l’application générale et du balisage de page.Also, an EventSetter abstracts method names for handlers one step further away from the general application and page markup.

Une autre syntaxe spécialisée qui combine l’événement routé et les fonctionnalités d' WPFWPF animation de EventTriggerest un.Another specialized syntax that combines the routed event and animation features of WPFWPF is an EventTrigger. Comme avec EventSetter, seuls les événements routés peuvent être utilisés pour EventTriggerun.As with EventSetter, only routed events may be used for an EventTrigger. En général, EventTrigger un est déclaré dans le cadre d’un style, EventTrigger mais un peut également être déclaré sur des éléments au niveau de la Triggers page dans le cadre de ControlTemplatela collection ou dans un.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. Vous permet de spécifier un Storyboard qui s’exécute chaque fois qu’un événement routé atteint un élément de son itinéraire qui déclare un EventTrigger pour cet événement. EventTriggerAn 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. L’avantage d’un EventTrigger surplus à gérer l’événement et le fait de démarrer une table de montage séquentiel EventTrigger existante est qu’un offre un meilleur contrôle sur la table de montage séquentiel et son comportement au moment de l’exécution.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. Pour plus d’informations, consultez Utiliser des déclencheurs d’événements pour contrôler un storyboard après son démarrage.For more information, see Use Event Triggers to Control a Storyboard After It Starts.

Informations complémentaires sur les événements routésMore About Routed Events

Cette rubrique traite principalement des concepts de base relatifs aux événements routés, et explique comment et à quel moment répondre aux événements routés qui sont déjà présents dans les différents éléments et contrôles de 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. Toutefois, vous pouvez créer vos propres événements routés dans votre classe personnalisée, ainsi que toute la prise en charge nécessaire, telle que les classes et les délégués spécialisés de données d’événement.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. Le propriétaire de l’événement routé peut être n’importe quelle classe, mais les événements routés doivent être déclenchés ContentElement par et gérés par ou par UIElement les classes dérivées afin d’être utiles.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. Pour plus d’informations sur les événements personnalisés, consultez Créer un événement routé personnalisé.For more information about custom events, see Create a Custom Routed Event.

Voir aussiSee also