Definizione di un evento

Per ulteriori informazioni sul modello delegato per gli eventi, vedere Gestione e generazione di eventi.

La funzionalità dell'evento viene fornita dai seguenti elementi.

• Una classe che contiene dati evento, ad esempio, EventArgs, ImageClickEventArgs.

• Un delegato dell'evento, ad esempio, EventHandler, ImageClickEventHandler.

  Nota   Le due classi riportate in precedenza vengono in genere definite all'esterno del controllo, mentre i due membri riportati di seguito vengono definiti nel controllo.

• Un membro evento definito nel controllo e identificato dalla parola chiave event.

• Un metodo nel controllo che richiama i delegati, ad esempio, OnClick, OnTextChanged.

Nell'esempio illustrato di seguito viene definito un evento Click nel controllo personalizzato MyButton.

// If the event does not generate data, you do not have
// to define a class for the event data or define an event delegate. 
// Use System.EventArgs for event data
// and System.EventHandler as the event delegate.
// MyButton uses EventHandler and EventArgs.

using System;
using System.Web.UI;

namespace CustomControls 
{  
   public class MyButton: Control, IPostBackEventHandler 
   {     
      // Defines the Click event.
      public event EventHandler Click;

      // OnClick dispatches the event to delegates that
      // are registered with the Click event.
      // Controls that derive from MyButton can handle the
      // Click event by overriding OnClick
      // instead of attaching a delegate. The event data
      // is passed as an argument to this method.
      protected virtual void OnClick(EventArgs e) 
      {     
         if (Click != null) 
         {
            Click(this, e);
         }  
      }
      
      // Method of IPostBackEventHandler that raises change events.
      public void RaisePostBackEvent(string eventArgument)
      {     
         OnClick(EventArgs.Empty);
      }
      
      protected override void Render(HtmlTextWriter output) 
      {     
         output.Write("<INPUT TYPE = submit name = " + this.UniqueID + 
            " Value = 'Click Me' />"); 
      }
   }    
}
[Visual Basic]
' If the event does not generate data, you do not have
' to define a class for the event data or define an event delegate. 
' Use System.EventArgs for event data
' and System.EventHandler as the event delegate.
' MyButton uses EventHandler and EventArgs.
Option Explicit
Option Strict

Imports System
Imports System.Web.UI

Namespace CustomControls
   Public Class MyButton
      Inherits Control
      Implements IPostBackEventHandler
      
      ' Defines the Click event.
      Public Event Click As EventHandler
      
      ' OnClick dispatches the event to delegates that
      ' are registered with the Click event.
      ' Controls that derive from MyButton can handle the
      ' Click event by overriding OnClick
      ' instead of attaching a delegate. The event data
      ' is passed as an argument to this method.
      Protected Overridable Sub OnClick(e As EventArgs)
         RaiseEvent Click(Me, e)
      End Sub
      
      ' Method of IPostBackEventHandler that raises change events.
      Public Sub RaisePostBackEvent(eventArgument As String) Implements IPostBackEventHandler.RaisePostBackEvent
         OnClick(EventArgs.Empty)
      End Sub 'RaisePostBackEvent
      
      Protected Overrides Sub Render(output As HtmlTextWriter)
         output.Write(("<INPUT TYPE = submit name = " & Me.UniqueID & " Value = 'Click Me' />"))
      End Sub
   End Class
End Namespace

Oltre a definire un evento, uno sviluppatore di controlli deve decidere le modalità di generazione dell'evento, ovvero da dove richiamare il metodo OnNomeEvento. Il controllo MyButton, ad esempio, genera l'evento Click dal relativo metodo RaisePostBackEvent, che fa parte del contratto IPostBackEventHandler. Per ulteriori informazioni su questo esempio, vedere Acquisizione dei dati di postback.

Ottimizzazione dell'implementazione degli eventi

L'implementazione dell'evento descritto nell'esempio precedente non risulta ottimizzato per le prestazioni, poiché viene generato un campo per ciascuna istanza di delegato. Questa operazione determina un incremento dei requisiti di memoria quando vengono definiti numerosi eventi su un controllo. La classe base System.Web.UI.Control fornisce, mediante la proprietà Events, una struttura di dati più efficiente per l'archiviazione e il recupero dei delegati dell'evento. La proprietà Events è di tipo EventHandlerList, una struttura di dati progettata per operazioni di archiviazione e recupero dei delegati dell'evento maggiormente efficienti. Nell'esempio riportato di seguito viene illustrata l'implementazione dell'evento mediante la proprietà Events. Questo esempio in C# differisce dall'esempio MyButton definito in precedenza solo in relazione all'implementazione dell'evento Click. Il codice che implementa tale evento è evidenziato in grassetto.

Nota   Le proprietà evento non sono supportate in questa versione di Visual Basic .NET.

using System;
using System.Web.UI;

namespace CustomControls 
{
   public class OptimizedEventButton: Control, IPostBackEventHandler 
   {
      // Defines a key for storing the delegate for the Click event
      // in the Events list.
      private static readonly object ClickEvent = new object();
      
      // Defines the Click event using the event property syntax.
      // The Events property stores all the event delegates of
      // a control as name/value pairs. 
      public event EventHandler Click 
      {
         // When a user attaches an event handler to the Click event 
         // (Click += myHandler;), the Add method 
         // adds the handler to the 
         // delegate for the Click event (keyed by ClickEvent 
         // in the Events list).
         add          {            Events.AddHandler(ClickEvent, value);         }
         // When a user removes an event handler from the Click event 
         // (Click -= myHandler;), the Remove method 
         // removes the handler from the 
         // delegate for the Click event (keyed by ClickEvent 
         // in the Events list).
         remove          {            Events.RemoveHandler(ClickEvent, value);         }
      }
      
      // Invokes delegates registered with the Click event.
      //
      protected virtual void OnClick(EventArgs e) 
      {
         // Retrieves the event delegate for the Click event
         // from the Events property (which stores
         // the control's event delegates). You must
         // cast the retrieved delegate to the type of your 
         // event delegate.
         EventHandler clickEventDelegate = (EventHandler)Events[ClickEvent];         if (clickEventDelegate != null) {            clickEventDelegate(this, e);         }  
      }
      
      // Method of IPostBackEventHandler that raises change events.
      //
      public void RaisePostBackEvent(string eventArgument)
      {
         
         OnClick(new EventArgs());
      }
      
      protected override void Render(HtmlTextWriter output) 
      {
         
         output.Write("<INPUT TYPE = submit name = " + this.UniqueID + 
            " Value = 'Click Me' />"); 
      }
   }    
}

Nota   Per maggiore semplicità, in alcuni esempi presenti nella documentazione gli eventi vengono definiti mediante i campi relativi agli eventi. Nei controlli, tuttavia, è necessario utilizzare l'implementazione ottimizzata illustrata in questa sezione.

Vedere anche

Gestione e generazione di eventi | Bubbling di un evento | Elaborazione dei dati di postback | Acquisizione di eventi postback | Generazione di script lato client per il postback