Este artigo foi traduzido por máquina. Para visualizar o arquivo em inglês, marque a caixa de seleção Inglês. Você também pode exibir o texto Em inglês em uma janela pop-up, movendo o ponteiro do mouse sobre o texto.
Tradução
Inglês

Consumindo Eventos

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.

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) {}

ObservaçãoObservaçã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){}

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çãoObservaçã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.

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.

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.


Contribuições da comunidade

Mostrar: