Consumindo Eventos

Artigo
08/25/2010

Para consumir um evento em um aplicativo você deve fornecer um manipulador de eventos (um método de manipulação de eventos) que executa lógica de programa em resposta ao evento e registra o manipulador de eventos junto a origem do evento.Este processo é conhecido como conexão de evento.Os designers visuais para Windows Forms e Web Forms fornecem ferramentas de desenvolvimento rápido de aplicativos (RAD) que simplificam ou ocultam os detalhes da conexão de evento.

Este tópico descreve o padrão geral de manipulação de eventos.Para obter uma visão geral do modelo de eventos na .NET Framework, consulte Eventos e Representantes.Para obter mais informações sobre o modelo de eventos nos Windows Forms, consulte Como: Consumir eventos em um aplicativo do Windows Forms.Para obter mais informações sobre o modelo de eventos nos Web Forms, consulte Como: Consumir eventos em um aplicativo de formulários da Web.

O Padrão de Evento

Os detalhes da conexão de evento diferem em Windows Forms e Web Forms por causa dos diferentes níveis de suporte fornecido por diferentes ferramentas RAD.No entanto, ambos os cenários seguem o mesmo padrão de evento, que possui as seguintes características:

Uma classe que gera um evento chamado EventName possui o membro a seguir:

public event EventNameEventHandler EventName;

Public Event EventName As EventNameEventHandler

O representante de evento para o evento EventName é EventName EventHandler , com a assinatura a seguir:

public delegate void EventNameEventHandler(object sender, EventNameEventArgs e);

Public Delegate Sub EventNameEventHandler(sender As Object, e As EventNameEventArgs)

Para consumir o evento EventName, o manipulador de eventos deve ter a mesma assinatura do representante de evento:

void EventHandler(object sender, EventNameEventArgs e) {}

Sub EventHandler(sender As Object, e As EventNameEventArgs)

Observação:
Um evento delegado no .NET estrutura é denominado evento Nomeevento Manipulador, enquanto o termo evento manipulador na documentação refere-se a um evento-método de manipulação.A lógica por trás o esquema de nomeação é que um EventNameEventHandler delegado aponta para o manipulador de eventos (método) que realmente manipula o evento.

Quando um evento não possui nenhum dado associado, a classe que está lançando o evento utiliza System.EventHandler como o representante e System.EventArgs como os dados do evento.Os eventos que associaram dados usam classes que derivam de EventArgs para o tipo de dados do evento e o tipo de representante de evento correspondente.Por exemplo, se você desejar manipular um evento MouseUp em um aplicativo Windows Forms , a classe de dados do evento é MouseEventArgs e o representante de evento é MouseEventHandler.Observe que vários eventos de mouse usam uma classe comum para dados do evento e um representante de eventos comum, de tal forma que o esquema de nomeação não coincida exatamente com a convenção descrita acima.Para os eventos de mouse, o manipulador de eventos deve ter a seguinte assinatura:

void Mouse_Moved(object sender, MouseEventArgs e){}

Sub Mouse_Moved(sender As Object, e As MouseEventArgs)

Os parâmetros do remetente e do argumento de evento fornecem detalhes adicionais sobre o evento de mouse para o manipulador de eventos.O objeto remetente indica o quê lançou o evento.O parâmetro MouseEventArgs fornece detalhes sobre o movimento do mouse que gerou o evento.Várias origens de eventos fornecem dados adicionais para o evento, e vários manipuladores de eventos usam os dados específicos do evento no processamento do evento.Para obter um exemplo que demonstra disparamento e lidar com evento s evento-dados específicos, consulte Como: Gerar e consumir eventos.

Observação:
Eventos também surgem fora do contexto de interfaces de usuário (UIs), e, na verdade, a .NET Framework inclui várias classes não UI que geram eventos.No entanto, todos os eventos seguem o padrão descrito aqui.

Para obter informações sobre como lançar eventos a partir de uma classe, consulte Lançando um Evento.

Estático e dinâmico de eventos

The .NET Framework permite que assinantes ao se registrar para notificações de evento estaticamente ou dinamicamente. Estático evento manipuladores estão em vigor durante a vida inteira da classe cuja s evento lidar com eles.Isso é o método mais comum de manipulação de eventos.Dinâmico evento manipuladores são explicitamente ativados e desativados durante a execução do programa, geralmente em resposta a alguma lógica condicional do programa.Por exemplo, eles podem ser usados se as notificações de evento são necessários somente sob certas condições ou se um aplicativo fornece vários manipuladores de eventos e condições de time de execução definem o apropriado para usar.

The EventInfo.AddEventHandler método adiciona manipuladores de eventos dinâmicos e a EventInfo.RemoveEventHandler método desativa-los. Os idiomas individuais também fornecem seus próprios recursos para manipular eventos dinamicamente.O exemplo a seguir define um TemperatureMonitor classe que gera um TemperatureTheshold evento sempre que a temperatura atinge um limite predefinido. Um manipulador de eventos que assina esse evento será ativado e desativado durante a execução do programa.

public class TemperatureEventArgs : Inherits EventArgs
   Private oldTemp As Decimal
   Private newTemp As Decimal

   Public ReadOnly Property OldTemperature As Decimal
      Get
         Return Me.oldTemp
      End Get   
   End Property

   Public ReadOnly Property NewTemperature As Decimal
      Get
         Return Me.newTemp
      End Get
   End Property

   Public Sub New(oldTemp As Decimal, newTemp As Decimal)
      Me.oldTemp = oldTemp
      Me.newTemp = newTemp   
   End Sub
End Class

Public Delegate Sub TemperatureEventHandler(sender As Object, _
                                            ev As TemperatureEventArgs)

Public Class TemperatureMonitor
   Private currentTemperature As Decimal
   Private threshholdTemperature As Decimal

   Public Event TemperatureThreshold As TemperatureEventHandler 

   Public Sub New(threshHold As Decimal)
      Me.threshholdTemperature = threshHold
   End Sub

   Public Sub SetTemperature(newTemperature As Decimal)
      If (Me.currentTemperature > threshholdTemperature And _
         newTemperature <= Me.threshholdTemperature) Or _
         (Me.CurrentTemperature < Me.threshholdTemperature And _
             newTemperature >= Me.threshholdTemperature) Then
         OnRaiseTemperatureEvent(newTemperature)
      End If
      Me.currentTemperature = newTemperature
   End Sub

   Public Function GetTemperature() As Decimal
      Return Me.currentTemperature
   End Function

   Protected Overridable Sub OnRaiseTemperatureEvent(newTemperature As Decimal)
      RaiseEvent TemperatureThreshold(Me, New TemperatureEventArgs(Me.currentTemperature, _ 
                                       newTemperature))
   End Sub                                       
End Class

Public Module Example
   Public Sub Main()
      Dim tempMon As New TemperatureMonitor(32d)
      tempMon.SetTemperature(33)
      Console.WriteLine("Current temperature is {0} degrees Fahrenheit.", _
                        tempMon.GetTemperature())
      tempMon.SetTemperature(32)
      Console.WriteLine("Current temperature is {0} degrees Fahrenheit.", _
                        tempMon.GetTemperature())

      ' Add event handler dynamically using Visual Basic syntax.
      AddHandler tempMon.TemperatureThreshold, AddressOf TempMonitor

      tempMon.SetTemperature(33)
      Console.WriteLine("Current temperature is {0} degrees Fahrenheit.", _
                        tempMon.GetTemperature())
      tempMon.SetTemperature(34)
      Console.WriteLine("Current temperature is {0} degrees Fahrenheit.", _
                        tempMon.GetTemperature())
      tempMon.SetTemperature(32)
      Console.WriteLine("Current temperature is {0} degrees Fahrenheit.", _
                        tempMon.GetTemperature())

      ' Remove event handler dynamically using Visual Basic syntax.
      RemoveHandler tempMon.TemperatureThreshold, AddressOf TempMonitor

      tempMon.SetTemperature(31)
      Console.WriteLine("Current temperature is {0} degrees Fahrenheit.", _ 
                        tempMon.GetTemperature())
      tempMon.SetTemperature(35)
      Console.WriteLine("Current temperature is {0} degrees Fahrenheit.", _ 
                        tempMon.GetTemperature())
   End Sub

   Private Sub TempMonitor(sender As Object, e As TemperatureEventArgs)
      Console.WriteLine("   ***Warning: Temperature is changing from {0} to {1}.", _ 
                        e.OldTemperature, e.NewTemperature)
   End Sub 
End Module
' The example displays the following output:
'       Current temperature is 33 degrees Fahrenheit.
'       Current temperature is 32 degrees Fahrenheit.
'       Current temperature is 33 degrees Fahrenheit.
'       Current temperature is 34 degrees Fahrenheit.
'          ***Warning: Temperature is changing from 34 to 32.
'       Current temperature is 32 degrees Fahrenheit.
'       Current temperature is 31 degrees Fahrenheit.
'       Current temperature is 35 degrees Fahrenheit.

using System;

public class TemperatureEventArgs : EventArgs
{
   private decimal oldTemp;
   private decimal newTemp;

   public decimal OldTemperature
   {
      get { return this.oldTemp; }
   }

   public decimal NewTemperature
   {
      get { return this.newTemp; }
   }

   public TemperatureEventArgs(decimal oldTemp, decimal newTemp)
   {
      this.oldTemp = oldTemp;
      this.newTemp = newTemp;   
   }
}

public delegate void TemperatureEventHandler(object sender, TemperatureEventArgs ev);

public class TemperatureMonitor
{
   private decimal currentTemperature;
   private decimal threshholdTemperature;

   public event TemperatureEventHandler TemperatureThreshold; 

   public TemperatureMonitor(decimal threshhold)
   {
      this.threshholdTemperature = threshhold;
   }

   public void SetTemperature(decimal newTemperature)
   {
      if ( (this.currentTemperature > this.threshholdTemperature && 
           newTemperature <= this.threshholdTemperature) ||
           (this.currentTemperature < this.threshholdTemperature &&
           newTemperature >= this.threshholdTemperature) )
         OnRaiseTemperatureEvent(newTemperature);
      this.currentTemperature = newTemperature;
   }

   public decimal GetTemperature()
   {
      return this.currentTemperature;
   }

   protected virtual void OnRaiseTemperatureEvent(decimal newTemperature)
   {
      // Raise the event if it has subscribers.
      if (TemperatureThreshold != null)
         TemperatureThreshold(this, new TemperatureEventArgs(this.currentTemperature, 
                               newTemperature));
   }
}

public class Example
{
   public static void Main()
   {
      Example ex = new Example();
      ex.MonitorTemperatures();
   }

   public void MonitorTemperatures()
   {
      TemperatureMonitor tempMon = new TemperatureMonitor(32);
      tempMon.SetTemperature(33);
      Console.WriteLine("Current temperature is {0} degrees Fahrenheit.", 
                        tempMon.GetTemperature());
      tempMon.SetTemperature(32);
      Console.WriteLine("Current temperature is {0} degrees Fahrenheit.",
                        tempMon.GetTemperature());

      // Add event handler dynamically using C# syntax.
      tempMon.TemperatureThreshold += this.TempMonitor;

      tempMon.SetTemperature(33);
      Console.WriteLine("Current temperature is {0} degrees Fahrenheit.", 
                        tempMon.GetTemperature());
      tempMon.SetTemperature(34);
      Console.WriteLine("Current temperature is {0} degrees Fahrenheit.", 
                        tempMon.GetTemperature());
      tempMon.SetTemperature(32);
      Console.WriteLine("Current temperature is {0} degrees Fahrenheit.",
                        tempMon.GetTemperature());

      // Remove event handler dynamically using C# syntax.
      tempMon.TemperatureThreshold -= this.TempMonitor;

      tempMon.SetTemperature(31);
      Console.WriteLine("Current temperature is {0} degrees Fahrenheit.", 
                        tempMon.GetTemperature());
      tempMon.SetTemperature(35);
      Console.WriteLine("Current temperature is {0} degrees Fahrenheit.", 
                        tempMon.GetTemperature());
   }

   private void TempMonitor(object sender, TemperatureEventArgs e)
   {
      Console.WriteLine("   ***Warning: Temperature is changing from {0} to {1}.", 
                        e.OldTemperature, e.NewTemperature);
   } 
}
// The example displays the following output:
//       Current temperature is 33 degrees Fahrenheit.
//       Current temperature is 32 degrees Fahrenheit.
//       Current temperature is 33 degrees Fahrenheit.
//       Current temperature is 34 degrees Fahrenheit.
//          ***Warning: Temperature is changing from 34 to 32.
//       Current temperature is 32 degrees Fahrenheit.
//       Current temperature is 31 degrees Fahrenheit.
//       Current temperature is 35 degrees Fahrenheit.

Consulte também

Consumindo Eventos

O Padrão de Evento

Estático e dinâmico de eventos

Consulte também

Tarefas

Conceitos

Outros recursos

Recursos adicionais