Cenni preliminari sugli eventi indirizzatiRouted Events Overview

Questo argomento descrive il concetto di eventi indirizzati in 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). L'argomento definisce la terminologia correlata agli eventi indirizzati, descrive in che modo questi eventi sono indirizzati lungo un albero di elementi, riepiloga le modalità di gestione degli eventi indirizzati e spiega come creare eventi indirizzati personalizzati.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.

PrerequisitiPrerequisites

In questo argomento si presuppone la conoscenza di base del Common Language Runtime (CLR) e della programmazione orientata a oggetti, nonché il concetto di come le relazioni tra WPFWPF gli elementi possano essere concettuali come albero.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. Per seguire gli esempi illustrati in questo argomento, è anche necessario conoscere Extensible Application Markup Language (XAML)Extensible Application Markup Language (XAML) e saper scrivere applicazioni o pagine WPFWPF di base.In order to follow the examples in this topic, you should also understand Extensible Application Markup Language (XAML)Extensible Application Markup Language (XAML) and know how to write very basic WPFWPF applications or pages. Per altre informazioni, vedere Procedura dettagliata: La prima applicazione desktop WPF e Cenni preliminari su XAML (WPF).For more information, see Walkthrough: My first WPF desktop application and XAML Overview (WPF).

Definizione di evento indirizzatoWhat Is a Routed Event?

È possibile considerare gli eventi indirizzati da un punto di vista funzionale o da una prospettiva di implementazione.You can think about routed events either from a functional or implementation perspective. In questo argomento sono illustrati entrambi i concetti, perché alcuni utenti trovano più utile il primo e altri il secondo.Both definitions are presented here, because some people find one or the other definition more useful.

Definizione funzionale: Un evento indirizzato è un tipo di evento che può richiamare i gestori su più listener in un albero degli elementi, anziché semplicemente sull'oggetto che ha generato l'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.

Definizione di implementazione: Un evento indirizzato è un evento CLR supportato da un'istanza della RoutedEvent classe e viene elaborato Windows Presentation Foundation (WPF)Windows Presentation Foundation (WPF) dal sistema di eventi.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.

Un'applicazione WPFWPF tipica contiene molti elementi.A typical WPFWPF application contains many elements. Indipendentemente dal fatto che vengano creati nel codice o dichiarati in XAMLXAML, questi elementi sono legati tra loro da una relazione di albero degli elementi.Whether created in code or declared in XAMLXAML, these elements exist in an element tree relationship to each other. La route dell'evento può procedere in una di due direzioni, in base alla definizione dell'evento, ma generalmente parte dall'elemento di origine e sale (bubbling) lungo l'albero degli elementi fino a raggiunge la radice dell'albero (in genere una pagina o una finestra).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). Questo concetto di bubbling può risultare familiare a chi in precedenza ha già usato il modello a oggetti DHTML.This bubbling concept might be familiar to you if you have worked with the DHTML object model previously.

Considerare il semplice albero degli elementi seguente: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>

Questo albero degli elementi produce un risultato analogo al seguente:This element tree produces something like the following:

Pulsanti Sì, No e AnnullaYes, No, and Cancel buttons

In questo albero di elementi semplificato, l'origine Click di un evento è uno Button degli elementi e qualunque Button sia stato selezionato è il primo elemento che ha la possibilità di gestire l'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. Tuttavia, se nessun gestore associato a Button agisce sull'evento, l'evento verrà ribolle verso l' Button alto nell'albero degli elementi, che è l'oggetto 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. Potenzialmente, l'evento viene sottoposta a Borderbubbling e quindi oltre alla radice della pagina dell'albero degli elementi (non mostrato).Potentially, the event bubbles to Border, and then beyond to the page root of the element tree (not shown).

In altre parole, la route dell'evento per Click questo evento è:In other words, the event route for this Click event is:

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

Scenari principali per gli eventi indirizzatiTop-level Scenarios for Routed Events

Di seguito è riportato un breve riepilogo degli scenari in cui è stato motivato il concetto di evento indirizzato e il motivo per cui un tipico evento CLR non era adatto a questi scenari: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:

Composizione e incapsulamento del controllo: Vari controlli in WPFWPF hanno un modello di contenuto avanzato.Control composition and encapsulation: Various controls in WPFWPF have a rich content model. Ad esempio, è possibile inserire un'immagine all'interno di Buttonun oggetto, che estende efficacemente la struttura ad albero visuale del pulsante.For example, you can place an image inside of a Button, which effectively extends the visual tree of the button. Tuttavia, l'immagine aggiunta non deve interrompere il comportamento di hit testing che fa in modo che un pulsante Click risponda a un del contenuto, anche se l'utente fa clic su pixel che fanno tecnicamente parte dell'immagine.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.

Punti di collegamento del gestore singolari: In Windows FormWindows Formsè necessario alleghi più volte lo stesso gestore per elaborare gli eventi che possono essere generati da più elementi.Singular handler attachment points: In Windows FormWindows Forms, you would have to attach the same handler multiple times to process events that could be raised from multiple elements. Gli eventi indirizzati consentono di associare il gestore una sola volta, come illustrato nell'esempio precedente, e di usare la logica del gestore per determinare da dove proviene l'evento, se necessario.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. Ad esempio, questo potrebbe essere il gestore per il codice XAMLXAML illustrato in precedenza: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

Gestione classi: Gli eventi indirizzati consentono un gestore statico definito dalla classe.Class handling: Routed events permit a static handler that is defined by the class. Questo gestore di classi ha la possibilità di gestire un evento prima di qualsiasi gestore di istanze associato.This class handler has the opportunity to handle an event before any attached instance handlers can.

Riferimento a un evento senza reflection: Alcune tecniche di codice e markup richiedono un modo per identificare un evento specifico.Referencing an event without reflection: Certain code and markup techniques require a way to identify a specific event. Un evento indirizzato crea un RoutedEvent campo come identificatore, che fornisce una tecnica di identificazione degli eventi affidabile che non richiede la reflection statica o in fase di esecuzione.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.

Modalità di implementazione degli eventi indirizzatiHow Routed Events Are Implemented

Un evento indirizzato è un evento CLR supportato da un'istanza della RoutedEvent classe e registrato con il WPFWPF sistema di eventi.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 istanza ottenuta dalla registrazione viene in genere mantenuta public static readonly come membro del campo della classe che esegue la registrazione e quindi "proprietario" dell'evento indirizzato.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 connessione all'evento CLR con nome identico (a volte definito evento "wrapper") viene eseguita eseguendo l'override delle add implementazioni e remove per l'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 e remove vengono lasciati come impostazione predefinita implicita che usa la sintassi di evento specifica del linguaggio per aggiungere e rimuovere i gestori dell'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. Il meccanismo di backup e di connessione degli eventi indirizzati è concettualmente simile al modo in cui una proprietà di dipendenza è una proprietà CLR supportata DependencyProperty dalla classe e registrata con WPFWPF il sistema di proprietà.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.

Nell'esempio seguente viene illustrata la dichiarazione per Tap un evento indirizzato personalizzato, incluse la registrazione e l' RoutedEvent esposizione del campo identificatore add e remove le implementazioni e Tap per l'evento 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

Gestori di eventi indirizzati e XAMLRouted Event Handlers and XAML

Per aggiungere un gestore per un evento usando XAMLXAML, il nome dell'evento deve essere dichiarato come attributo dell'elemento che è un listener di eventi.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. Il valore dell'attributo è il nome del metodo del gestore implementato, che deve trovarsi nella classe parziale del file 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 sintassi per l'aggiunta di gestori eventi CLR standard è la stessa per l'aggiunta di gestori di eventi indirizzati, perché si aggiungono effettivamente gestori al wrapper di eventi CLR, che include un'implementazione di eventi indirizzati sotto.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. Per altre informazioni sull'aggiunta di gestori eventi in XAMLXAML, vedere Cenni preliminari su XAML (WPF).For more information about adding event handlers in XAMLXAML, see XAML Overview (WPF).

Strategie di routingRouting Strategies

Gli eventi indirizzati usano una delle tre strategie di routing illustrate di seguito:Routed events use one of three routing strategies:

  • Bubbling Vengono richiamati i gestori eventi nell'origine evento.Bubbling: Event handlers on the event source are invoked. L'evento indirizzato viene quindi indirizzato agli elementi padre successivi fino a raggiungere la radice dell'albero degli elementi.The routed event then routes to successive parent elements until reaching the element tree root. La maggior parte degli eventi indirizzati usa la strategia di bubbling.Most routed events use the bubbling routing strategy. Gli eventi indirizzati di bubbling vengono in genere usati per segnalare l'input o le modifiche dello stato da controlli distinti o altri elementi dell'interfaccia utente.Bubbling routed events are generally used to report input or state changes from distinct controls or other UI elements.

  • Diretto Solo all'elemento di origine viene data la possibilità di richiamare i gestori in risposta.Direct: Only the source element itself is given the opportunity to invoke handlers in response. Questa strategia è analoga al "routing" usato da Windows FormWindows Forms per gli eventi.This is analogous to the "routing" that Windows FormWindows Forms uses for events. Tuttavia, a differenza di un evento CLR standard, gli eventi indirizzati diretti supportano la gestione delle classi (la gestione delle classi viene illustrata in una sezione EventSetter imminente) e può essere usata da e. EventTriggerHowever, 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 Inizialmente vengono richiamati i gestori eventi alla radice dell'albero degli elementi.Tunneling: Initially, event handlers at the element tree root are invoked. L'evento indirizzato percorre quindi una route attraverso elementi figlio successivi, verso l'elemento nodo che rappresenta l'origine dell'evento indirizzato (l'elemento che ha generato l'evento indirizzato).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). Gli eventi indirizzati di tunneling vengono spesso usati o gestiti come parte della composizione di un controllo, in modo che gli eventi di parti composite possano essere deliberatamente eliminati o sostituiti da eventi specifici del controllo 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. Gli eventi di input forniti in WPFWPF vengono spesso implementati come coppia di tunneling/bubbling.Input events provided in WPFWPF often come implemented as a tunneling/bubbling pair. Gli eventi di tunneling sono talvolta anche detti eventi di anteprima, per una convenzione di denominazione usata per le coppie.Tunneling events are also sometimes referred to as Preview events, because of a naming convention that is used for the pairs.

Vantaggi offerti dall'uso degli eventi indirizzatiWhy Use Routed Events?

Per gli sviluppatori di applicazioni non è sempre necessario o importante sapere se l'evento gestito è implementato come evento indirizzato.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. Gli eventi indirizzati hanno un comportamento speciale, che però è per lo più invisibile se l'evento viene gestito sull'elemento in cui è stato generato.Routed events have special behavior, but that behavior is largely invisible if you are handling an event on the element where it is raised.

Gli eventi indirizzati diventano particolarmente efficaci se si usa uno degli scenari suggeriti: definizione di gestori comuni in una radice comune, composizione di un controllo personalizzato o definizione di una classe di controlli personalizzata.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.

Non è necessario che i listener e le origini degli eventi indirizzati condividano un evento comune nella gerarchia.Routed event listeners and routed event sources do not need to share a common event in their hierarchy. Any UIElement oContentElement può essere un listener di eventi per qualsiasi evento indirizzato.Any UIElement or ContentElement can be an event listener for any routed event. È quindi possibile usare il set completo di eventi indirizzati disponibili nell'API di lavoro come "interfaccia" concettuale, in cui gli elementi diversi dell'applicazione possono scambiare informazioni sugli eventi.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. Questo concetto di "interfaccia" per gli eventi indirizzati è applicabile in particolar modo agli eventi di input.This "interface" concept for routed events is particularly applicable for input events.

Gli eventi indirizzati possono anche essere usati per comunicare nell'albero degli elementi, poiché i dati di un evento vengono trasmessi a ogni elemento nella route.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. Se un elemento modifica in qualche modo i dati dell'evento, tale modifica risulta disponibile per l'elemento successivo nella route.One element could change something in the event data, and that change would be available to the next element in the route.

Oltre all'aspetto del routing, esistono altri due motivi per cui un determinato WPFWPF evento può essere implementato come un evento indirizzato anziché un evento 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. Se si implementano eventi personalizzati, considerare anche questi principi:If you are implementing your own events, you might also consider these principles:

  • Alcune WPFWPF funzionalità di applicazione di stili e EventSetter modelli EventTrigger , ad esempio e, richiedono che l'evento a cui si fa riferimento sia un evento indirizzato.Certain WPFWPF styling and templating features such as EventSetter and EventTrigger require the referenced event to be a routed event. Si tratta dello scenario di identificatore dell'evento citato in precedenza.This is the event identifier scenario mentioned earlier.

  • Gli eventi indirizzati supportano un meccanismo di gestione delle classi in base al quale la classe può specificare metodi statici che hanno la possibilità di gestire gli eventi indirizzati prima che qualsiasi gestore di istanze registrato possa accedervi.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. Questa funzionalità è molto utile nella progettazione di controlli, perché la classe può imporre comportamenti di classe basati su eventi che non possono essere eliminati accidentalmente mediante la gestione di un evento su un'istanza.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.

Ognuna delle considerazioni precedenti viene discussa in una sezione separata di questo argomento.Each of the above considerations is discussed in a separate section of this topic.

Aggiunta e implementazione di un gestore eventi per un evento indirizzatoAdding and Implementing an Event Handler for a Routed Event

Per aggiungere un gestore eventi in XAMLXAML, è sufficiente aggiungere il nome dell'evento a un elemento come attributo e impostare il valore dell'attributo come nome del gestore eventi che implementa un delegato appropriato, come nell'esempio seguente.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>

b1SetColornome del gestore implementato che contiene il codice che gestisce l' Click evento.b1SetColor is the name of the implemented handler that contains the code that handles the Click event. b1SetColordeve avere la stessa firma RoutedEventHandler del delegato, che è il delegato del gestore eventi per l' Click evento.b1SetColor must have the same signature as the RoutedEventHandler delegate, which is the event handler delegate for the Click event. Il primo parametro di tutti i delegati dei gestori di eventi indirizzati specifica l'elemento a cui viene aggiunto il gestore eventi, mentre il secondo parametro specifica i dati per l'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è il delegato del gestore dell'evento indirizzato di base.RoutedEventHandler is the basic routed event handler delegate. Per gli eventi indirizzati specializzati per determinati controlli o scenari, i delegati da usare per i gestori di eventi indirizzati possono anche essere più specializzati, in modo da poter trasmettere dati di eventi specializzati.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. In uno scenario di input comune, ad esempio, è possibile gestire DragEnter un evento indirizzato.For instance, in a common input scenario, you might handle a DragEnter routed event. Il gestore deve implementare il DragEventHandler delegato.Your handler should implement the DragEventHandler delegate. Usando il delegato più specifico, è possibile elaborare l'oggetto DragEventArgs nel gestore e leggere la Data proprietà, che contiene il payload degli Appunti dell'operazione di trascinamento.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.

Per un esempio completo di come aggiungere un gestore eventi a un elemento usando XAMLXAML, vedere Gestire un evento indirizzato.For a complete example of how to add an event handler to an element using XAMLXAML, see Handle a Routed Event.

L'aggiunta di un gestore per un evento indirizzato in un'applicazione creata nel codice è semplice.Adding a handler for a routed event in an application that is created in code is straightforward. I gestori di eventi indirizzati possono sempre essere aggiunti tramite un metodo AddHandler helper, ovvero lo stesso metodo che il backup esistente chiama per. add Tuttavia, gli eventi indirizzati WPFWPF esistenti hanno in genere implementazioni di supporto per la logica add e remove che consentono l'aggiunta di gestori per gli eventi indirizzati tramite una sintassi di evento specifica del linguaggio, che è più intuitiva rispetto al metodo helper.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. Di seguito è illustrato un esempio di utilizzo del metodo helper: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

Nell'esempio seguente viene illustrata la C# sintassi dell'operatore (Visual Basic presenta una sintassi di operatore leggermente diversa a causa della relativa gestione della dereferenziazione):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

Per un esempio di come aggiungere un gestore eventi nel codice, vedere Aggiungere un gestore eventi mediante codice.For an example of how to add an event handler in code, see Add an Event Handler Using Code.

Se si utilizza Visual Basic, è inoltre possibile utilizzare la Handles parola chiave per aggiungere gestori come parte delle dichiarazioni del gestore.If you are using Visual Basic, you can also use the Handles keyword to add handlers as part of the handler declarations. Per altre informazioni, vedere Visual Basic e la gestione degli eventi WPF.For more information, see Visual Basic and WPF Event Handling.

Concetto di gestitoThe Concept of Handled

Tutti gli eventi indirizzati condividono una classe di base dei dati RoutedEventArgsdi evento comuni,.All routed events share a common event data base class, RoutedEventArgs. RoutedEventArgsdefinisce la Handled proprietà, che accetta un valore booleano.RoutedEventArgs defines the Handled property, which takes a Boolean value. Lo scopo della Handled proprietà è quello di abilitare qualsiasi gestore eventi lungo la route per contrassegnare l'evento indirizzato come gestito, impostando il valore Handled di truesu.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. Dopo essere stati elaborati dal gestore in corrispondenza di un elemento lungo la route, i dati di evento condivisi vengono nuovamente segnalati a ogni listener lungo la route.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.

Il valore di Handled influiscono sul modo in cui un evento indirizzato viene segnalato o elaborato mentre si sposta ulteriormente lungo la route.The value of Handled affects how a routed event is reported or processed as it travels further along the route. Se Handled ètrue nei dati dell'evento per un evento indirizzato, i gestori che restano in attesa di tale evento indirizzato su altri elementi in genere non vengono più richiamati per quella particolare istanza di evento.If Handled is true in the event data for a routed event, then handlers that listen for that routed event on other elements are generally no longer invoked for that particular event instance. Ciò vale sia per i gestori associati in XAMLXAML che per i gestori aggiunti da sintassi di associazione dei gestori eventi specifiche del linguaggio, come += 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. Per gli scenari di gestione più comuni, contrassegnare un evento come Handled gestito true impostando su verrà interrotto il routing per una route di tunneling o una route di bubbling e anche per qualsiasi evento gestito in un punto della route da un gestore di 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.

Tuttavia, esiste un meccanismo "handledEventsToo" in cui i listener possono comunque eseguire i gestori in risposta agli eventi indirizzati in Handled cui true si trova nei dati dell'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. In altre parole, la route dell'evento non viene effettivamente interrotta contrassegnando i dati di evento come gestiti.In other words, the event route is not truly stopped by marking the event data as handled. È possibile usare il meccanismo handledEventsToo solo nel codice o in un EventSetter:You can only use the handledEventsToo mechanism in code, or in an EventSetter:

Oltre al comportamento che Handled lo stato produce negli eventi indirizzati, il concetto di Handled presenta implicazioni per la progettazione dell'applicazione e la scrittura del codice del gestore eventi.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. È possibile concettualizzare Handled come un semplice protocollo esposto dagli eventi indirizzati.You can conceptualize Handled as being a simple protocol that is exposed by routed events. Il modo in cui si usa questo protocollo dipende dall'utente, ma la progettazione concettuale per la modalità Handled di utilizzo del valore di è la seguente: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:

  • Se un evento indirizzato è contrassegnato come gestito, non è necessario che venga gestito nuovamente da altri elementi lungo la route.If a routed event is marked as handled, then it does not need to be handled again by other elements along that route.

  • Se un evento indirizzato non è contrassegnato come gestito, altri listener precedenti lungo la Route hanno scelto di non registrare un gestore o i gestori registrati hanno scelto di non modificare i dati dell'evento e impostare Handled su. trueIf 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. È anche possibile, ovviamente, che il listener corrente sia il primo punto nella route. I gestori sul listener corrente a questo punto hanno tre possibilità:(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:

    • Non eseguire alcuna azione. L'evento rimane non gestito e viene indirizzato al listener successivo.Take no action at all; the event remains unhandled, and the event routes to the next listener.

    • Eseguire il codice in risposta all'evento, ma stabilire che l'azione eseguita non è sufficiente per contrassegnare l'evento come gestito.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'evento viene indirizzato al listener successivo.The event routes to the next listener.

    • Eseguire il codice in risposta all'evento.Execute code in response to the event. Contrassegnare l'evento come gestito nei dati di evento passati al gestore, perché l'azione eseguita viene ritenuta sufficiente per contrassegnare l'evento come gestito.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'evento viene ancora indirizzato al listener successivo, ma Handled con = true nei dati degli eventi, quindi handledEventsToo solo i listener hanno la possibilità di richiamare ulteriori gestori.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.

Questa progettazione concettuale è rafforzata dal comportamento del routing indicato in precedenza: è più difficile (anche se ancora possibile nel codice o negli stili) allineare i gestori per gli eventi indirizzati che vengono richiamati anche se un gestore precedente lungo la route è già impostato Handled atrue.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.

Per ulteriori informazioni su Handled, gestione delle classi degli eventi indirizzati e indicazioni su quando è opportuno contrassegnare un evento indirizzato come Handled, vedere contrassegno degli eventi indirizzati come gestiti e gestione delle classi.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.

Nelle applicazioni, è piuttosto comune gestire un evento indirizzato di bubbling solo sull'oggetto che lo ha generato, senza preoccuparsi delle caratteristiche di routing dell'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. È tuttavia comunque consigliabile contrassegnare l'evento indirizzato come gestito nei dati di evento, per evitare effetti collaterali imprevisti nel caso in cui un elemento più in alto nell'albero degli elementi abbia un gestore associato per lo stesso evento indirizzato.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.

Gestori di classiClass Handlers

Se si definisce una classe che deriva in qualche modo da DependencyObject, è anche possibile definire e allineare un gestore di classi per un evento indirizzato che è un membro di evento dichiarato o ereditato della 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. I gestori di classi vengono richiamati prima dei gestori di listener di istanze associati a un'istanza di tale classe, ogni volta che un evento indirizzato raggiunge un'istanza dell'elemento nella relativa route.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.

Alcuni controlli WPFWPF hanno una gestione intrinseca delle classi per determinati eventi indirizzati.Some WPFWPF controls have inherent class handling for certain routed events. In questo modo potrebbe sembrare che l'evento indirizzato non venga mai generato, ma in realtà viene gestito tramite classi e, usando determinate tecniche, può essere ancora gestito dai gestori di istanze.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. Molti controlli e classi di base, inoltre, espongono metodi virtuali che possono essere usati per eseguire l'override del comportamento di gestione delle classi.Also, many base classes and controls expose virtual methods that can be used to override class handling behavior. Per altre informazioni su come evitare un comportamento di gestione delle classi non desiderato e su come definire la gestione delle classi in una classe personalizzata, vedere Contrassegno degli eventi indirizzati come gestiti e gestione delle classi.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.

Eventi associati in WPFAttached Events in WPF

Il linguaggio XAMLXAML definisce anche un tipo di evento speciale noto come evento associato.The XAMLXAML language also defines a special type of event called an attached event. Un evento associato consente di aggiungere un gestore per un determinato evento a un elemento arbitrario.An attached event enables you to add a handler for a particular event to an arbitrary element. L'elemento che gestisce l'evento non deve necessariamente definire o ereditare l'evento associato, né l'oggetto che genera potenzialmente l'evento o l'istanza di gestione di destinazione deve necessariamente definire o "possedere" in altro modo tale evento come membro della 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.

Il sistema di input di WPFWPF fa largo uso degli eventi associati.The WPFWPF input system uses attached events extensively. Tuttavia, quasi tutti questi eventi associati vengono inoltrati tramite elementi di base.However, nearly all of these attached events are forwarded through base elements. Gli eventi di input appaiono quindi come eventi indirizzati non associati equivalenti, membri della classe di elementi di base.The input events then appear as equivalent non-attached routed events that are members of the base element class. Ad esempio Mouse.MouseDown , l'evento associato sottostante può essere gestito in modo più semplice in qualsiasi dato MouseDown UIElement usando su UIElement , invece di gestire la sintassi degli eventi collegati in XAMLXAML o nel codice.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.

Per altre informazioni sugli eventi associati in WPFWPF, vedere Cenni preliminari sugli eventi associati.For more information about attached events in WPFWPF, see Attached Events Overview.

Nomi di evento completi in XAMLQualified Event Names in XAML

Un altro utilizzo della sintassi simile alla sintassi dell'evento associato nometipo.nomeevento, che però non è esattamente un utilizzo di un evento associato, è rappresentato dall'associazione di gestori per eventi indirizzati generati da elementi figlio.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. I gestori vengono associati a un elemento padre comune, per sfruttare il routing degli eventi, anche se l'evento indirizzato rilevante potrebbe non essere membro dell'elemento padre comune.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. Si consideri di nuovo questo esempio: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>

Qui, il listener dell'elemento padre in cui viene aggiunto il gestore StackPanelè.Here, the parent element listener where the handler is added is a StackPanel. Tuttavia, viene aggiunto un gestore per un evento indirizzato che è stato dichiarato e che verrà generato dalla Button classe (ButtonBase effettivamente, ma disponibile a Button tramite ereditarietà).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"proprietario" dell'evento, ma il sistema di eventi indirizzati consente ai gestori per qualsiasi evento indirizzato di essere collegato a UIElement qualsiasi ContentElement listener di istanze o che potrebbe altrimenti collegare listener per 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. Lo spazio dei nomi xmlns predefinito per questi nomi completi di attributo di evento è in genere lo spazio dei nomi xmlns WPFWPF predefinito, ma è anche possibile specificare spazi dei nomi con prefisso per eventi indirizzati personalizzati.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. Per altre informazioni su xmlns, vedere Spazi dei nomi XAML e mapping dello spazio dei nomi per XAML WPF.For more information about xmlns, see XAML Namespaces and Namespace Mapping for WPF XAML.

Eventi di input WPFWPF Input Events

Un'applicazione frequente degli eventi indirizzati nella piattaforma WPFWPF riguarda gli eventi di input.One frequent application of routed events within the WPFWPF platform is for input events. In WPFWPF i nomi degli eventi indirizzati di tunneling sono preceduti dalla parola "Preview" per convenzione.In WPFWPF, tunneling routed events names are prefixed with the word "Preview" by convention. Gli eventi di input sono spesso in coppia, con un evento che rappresenta l'evento di bubbling e l'altro quello di tunneling.Input events often come in pairs, with one being the bubbling event and the other being the tunneling event. Ad esempio, l' KeyDown evento e l' PreviewKeyDown evento hanno la stessa firma, il primo è l'evento di input di bubbling e il secondo è l'evento di input di 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. In alcuni casi, gli eventi di input hanno solo una versione di bubbling o solo una versione indirizzata diretta.Occasionally, input events only have a bubbling version, or perhaps only a direct routed version. Nella documentazione, gli argomenti relativi agli eventi indirizzati contengono riferimenti incrociati a eventi indirizzati simili con strategie di routing alternative, se disponibili, e le sezioni nelle pagine di riferimenti gestiti chiariscono la strategia di routing per ogni evento indirizzato.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.

Gli eventi di input WPFWPF in coppia vengono implementati in modo che una singola azione di input dell'utente, ad esempio la pressione di un pulsante del mouse, generi entrambi gli eventi indirizzati della coppia in sequenza.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. Per prima cosa, viene generato l'evento di tunneling, che avanza nella route.First, the tunneling event is raised and travels its route. Successivamente, viene generato l'evento di bubbling, che avanza nella route.Then the bubbling event is raised and travels its route. I due eventi condividono letteralmente la stessa istanza di dati evento, perché RaiseEvent la chiamata al metodo nella classe di implementazione che genera l'evento di bubbling resta in attesa dei dati dell'evento dell'evento di tunneling e la riutilizza nel nuovo evento generato.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. I listener con gestori per l'evento di tunneling hanno l'opportunità di contrassegnare per primi l'evento indirizzato come gestito (prima i gestori di classi, quindi i gestori di istanze).Listeners with handlers for the tunneling event have the first opportunity to mark the routed event handled (class handlers first, then instance handlers). Se un elemento nella route di tunneling ha contrassegnato l'evento indirizzato come gestito, i dati dell'evento già gestito vengono inviati per l'evento di bubbling e i gestori tipici associati per gli eventi di input di bubbling equivalenti non vengono richiamati.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. Dall'esterno, potrebbe sembrare che l'evento di bubbling gestito non sia mai stato generato.To outward appearances it will be as if the handled bubbling event has not even been raised. Questo comportamento di gestione è utile per la composizione di controlli in cui si vuole che tutti gli eventi di input basati su hit test o gli eventi di input basati su stato attivo vengano segnalati dal controllo finale, invece che dalle relative parti composite.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. L'elemento del controllo finale è più vicino alla radice nella composizione e quindi ha la possibilità di gestire tramite classi prima l'evento di tunneling ed eventualmente di "sostituire" tale evento indirizzato con un evento più specifico del controllo, come parte del codice sottostante la classe del controllo.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.

Come dimostrazione del funzionamento dell'elaborazione degli eventi di input, considerare l'esempio di evento di input seguente.As an illustration of how input event processing works, consider the following input event example. Nell'illustrazione leaf element #2 dell'albero seguente è l'origine di un oggetto PreviewMouseDown e quindi di un MouseDown evento:In the following tree illustration, leaf element #2 is the source of both a PreviewMouseDown and then a MouseDown event:

Diagramma del routing degli eventi

L'ordine di elaborazione degli eventi è il seguente:The order of event processing is as follows:

  1. PreviewMouseDown (tunneling) sull'elemento radice.PreviewMouseDown (tunnel) on root element.

  2. PreviewMouseDown (tunneling) sull'elemento intermedio 1.PreviewMouseDown (tunnel) on intermediate element #1.

  3. PreviewMouseDown (tunneling) sull'elemento di origine 2.PreviewMouseDown (tunnel) on source element #2.

  4. MouseDown (bubbling) sull'elemento di origine 2.MouseDown (bubble) on source element #2.

  5. MouseDown (bubbling) sull'elemento intermedio 1.MouseDown (bubble) on intermediate element #1.

  6. MouseDown (bubbling) sull'elemento radice.MouseDown (bubble) on root element.

Un delegato di un gestore di eventi indirizzati fornisce riferimenti a due oggetti: l'oggetto che ha generato l'evento e quello su cui è stato richiamato il gestore.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'oggetto in cui è stato richiamato il gestore è quello indicato dal parametro sender.The object where the handler was invoked is the object reported by the sender parameter. L'oggetto in cui l'evento è stato generato per la prima Source volta viene segnalato dalla proprietà nei dati dell'evento.The object where the event was first raised is reported by the Source property in the event data. Un evento indirizzato può comunque essere generato e gestito dallo stesso oggetto, nel qual caso sender e Source sono identici (questo è il caso dei passaggi 3 e 4 nell'elenco di esempio di elaborazione degli eventi).A routed event can still be raised and handled by the same object, in which case sender and Source are identical (this is the case with Steps 3 and 4 in the event processing example list).

A causa del tunneling e del bubbling, gli elementi padre ricevono gli eventi Source di input in cui è uno dei rispettivi elementi figlio.Because of tunneling and bubbling, parent elements receive input events where the Source is one of their child elements. Quando è importante conoscere l'elemento di origine, è possibile identificare l'elemento di origine accedendo alla Source proprietà.When it is important to know what the source element is, you can identify the source element by accessing the Source property.

In genere, una volta contrassegnato Handledl'evento di input, non vengono richiamati altri gestori.Usually, once the input event is marked Handled, further handlers are not invoked. Solitamente è consigliabile contrassegnare gli eventi di input come gestiti non appena viene richiamato un gestore che applica la gestione logica specifica dell'applicazione al significato dell'evento di input.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'eccezione a questa istruzione generale sullo Handled stato è che i gestori di eventi di input registrati per ignorare Handled intenzionalmente lo stato dei dati dell'evento verrebbero comunque richiamati lungo entrambe le route.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. Per altre informazioni, vedere Eventi di anteprima e Contrassegno degli eventi indirizzati come gestiti e gestione delle classi.For more information, see Preview Events or Marking Routed Events as Handled, and Class Handling.

Il modello di dati di evento condivisi tra eventi di tunneling e di bubbling e la generazione sequenziale di eventi prima di tunneling e quindi di bubbling non sono concetti generalmente veri per tutti gli eventi indirizzati.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. Questo comportamento viene implementato specificamente dal modo in cui i dispositivi di input WPFWPF scelgono di generare e connettere le coppie di eventi di input.That behavior is specifically implemented by how WPFWPF input devices choose to raise and connect the input event pairs. L'implementazione di eventi di input personalizzati è un scenario avanzato, ma si può scegliere di seguire tale modello anche per gli eventi di input personalizzati.Implementing your own input events is an advanced scenario, but you might choose to follow that model for your own input events also.

Alcune classi scelgono di gestire tramite classi determinati eventi di input, di solito con lo scopo di ridefinire il significato di un determinato evento di input generato dall'utente all'interno del controllo e di generare un nuovo 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. Per altre informazioni, vedere Contrassegno degli eventi indirizzati come gestiti e gestione delle classi.For more information, see Marking Routed Events as Handled, and Class Handling.

Per altre informazioni sull'input e su come input ed eventi interagiscono in scenari di applicazioni tipici, vedere Cenni preliminari sull'input.For more information on input and how input and events interact in typical application scenarios, see Input Overview.

EventSetters ed EventTriggersEventSetters and EventTriggers

Negli stili è possibile includere una sintassi di gestione degli XAMLXAML eventi pre-dichiarata nel markup usando EventSetterun oggetto.In styles, you can include some pre-declared XAMLXAML event handling syntax in the markup by using an EventSetter. Quando lo stile viene applicato, il gestore a cui si fa riferimento viene aggiunto all'istanza a cui è stato applicato lo stile.When the style is applied, the referenced handler is added to the styled instance. È possibile dichiarare un EventSetter solo per un evento indirizzato.You can declare an EventSetter only for a routed event. Di seguito è riportato un esempio.The following is an example. Si noti che il metodo b1SetColor a cui si fa riferimento qui si trova in un file 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>

Il vantaggio ottenuto è che è probabile che lo stile contenga una grande quantità di informazioni che possono essere applicate a qualsiasi pulsante nell'applicazione e che la parte di EventSetter tale stile promuova il riutilizzo del codice anche a livello di markup.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. Inoltre, un EventSetter metodo astrae i nomi dei metodi per i gestori un passo dopo l'altro rispetto al markup generale dell'applicazione e della pagina.Also, an EventSetter abstracts method names for handlers one step further away from the general application and page markup.

Un'altra sintassi specializzata che combina gli eventi indirizzati e le funzionalità WPFWPF di animazione EventTriggerdi è un.Another specialized syntax that combines the routed event and animation features of WPFWPF is an EventTrigger. Come con EventSetter, solo gli eventi indirizzati possono essere utilizzati per EventTriggerun oggetto.As with EventSetter, only routed events may be used for an EventTrigger. In genere, EventTrigger un oggetto viene dichiarato come parte di uno stile, EventTrigger ma un oggetto può anche essere dichiarato in Triggers elementi a livello di pagina come parte della raccolta o ControlTemplatein un oggetto.Typically, an EventTrigger is declared as part of a style, but an EventTrigger can also be declared on page-level elements as part of the Triggers collection, or in a ControlTemplate. Un EventTrigger oggetto consente di specificare un Storyboard oggetto che viene eseguito ogni volta che un evento indirizzato raggiunge un elemento nella relativa route EventTrigger che dichiara un oggetto per l'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. Il vantaggio di un EventTrigger rispetto alla gestione dell'evento e l'avvio di uno storyboard esistente consiste nel fatto che EventTrigger un oggetto fornisce un controllo migliore sullo storyboard e sul comportamento in fase di esecuzione.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. Per altre informazioni, vedere Usare i trigger di evento per controllare uno storyboard dopo il relativo avvio.For more information, see Use Event Triggers to Control a Storyboard After It Starts.

Altre informazioni sugli eventi indirizzatiMore About Routed Events

Questo argomento illustra gli eventi indirizzati principalmente con lo scopo di descrivere i concetti di base e di fornire istruzioni su come e quando rispondere agli eventi indirizzati già presenti nei vari controlli ed elementi di 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. È tuttavia possibile creare un evento indirizzato personalizzato in una classe personalizzata insieme a tutto il supporto necessario, come delegati e classi di dati di evento specializzati.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. Il proprietario dell'evento indirizzato può essere qualsiasi classe, ma gli eventi indirizzati devono essere generati da e UIElement gestiti ContentElement da classi derivate o per essere utili.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. Per altre informazioni sugli eventi personalizzati, vedere Creare un evento indirizzato personalizzato.For more information about custom events, see Create a Custom Routed Event.

Vedere ancheSee also