Używające zdarzeń

  • Artykuł

Aby zużywają zdarzenie w aplikacji, należy podać obsługi zdarzeń (metoda obsługi zdarzeń), że logika programu jest wykonywany w odpowiedzi na zdarzenie i zarejestrować obsługi zdarzenia ze źródłem zdarzeń. Ten proces jest zwany okablowania zdarzenia. Wizualnych projektantów umożliwiających Windows Forms i formularzy sieci Web oferują aplikacji szybkiego rozwoju (RAD) narzędzia uproszczenia lub ukryć szczegóły zdarzenia okablowania.

W tym temacie opisano ogólnym modelem obsługi zdarzeń. Aby uzyskać omówienie modelu zdarzeń w.NET Framework, zobacz zdarzenia i delegatów. Aby uzyskać więcej informacji na temat modelu zdarzeń w Windows Forms, zobacz Jak: zużywają zdarzeń w aplikacji Windows Forms. Aby uzyskać więcej informacji na temat modelu zdarzeń w formularzach sieci Web, zobacz Jak: zużywają zdarzeń w aplikacji formularzy sieci Web.

Deseń zdarzeń

Szczegóły zdarzenia okablowania różnią się w formularzach sieci Web i Windows Forms ze względu na różne poziomy pomocy świadczonej przez różne narzędzia RAD. Jednakże obu scenariuszy wykonaj deseń zdarzenia samego posiada następujące cechy:

  • Klasa, która wywołuje zdarzenie o nazwie EventName ma następujące Członkowskie:
Public Event EventName As EventNameEventHandler

public event EventNameEventHandler EventName;

public:
    event EventNameEventHandler^ EventName;
  • Delegata zdarzenia dla EventName jest zdarzenie EventNameEventHandler, z następujący podpis:
Public Delegate Sub EventNameEventHandler(sender As Object, e As EventNameEventArgs)

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

delegate void EventNameEventHandler(Object^ sender, EventNameEventArgs^ e);

Aby wykorzystać EventName zdarzenie, obsługi zdarzenia musi mieć taką samą sygnaturę jak zdarzenia, delegowanie:

Sub EventHandler(sender As Object, e As EventNameEventArgs)
End Sub

void EventHandler(object sender, EventNameEventArgs e) {}

void EventHandler(Object^ sender, EventNameEventArgs^ e) {}

Uwaga

Delegata zdarzenia.NET Framework jest o nazwie EventNameEventHandler, podczas gdy program obsługi zdarzeń termin w dokumentacji odnosi się do metody obsługi zdarzeń.Jest to, że logiki schemat nazewnictwa EventNameEventHandler delegować punktów do obsługi zdarzeń (metody) faktycznie obsługuje zdarzenie.

Gdy zdarzenie nie ma żadnych skojarzonych danych, korzysta z klasy, powodującemu zdarzenie System.EventHandler jako pełnomocnik i System.EventArgs na dane zdarzenie. Zdarzenia, które zostało skojarzone danych użyć klas, które wynikają z EventArgs na dane zdarzenie typu i odpowiednie zdarzenie typ delegata. Na przykład, jeśli chcesz obsługiwać MouseUp jest klasa zdarzenia dane zdarzenie w aplikacji Windows Forms MouseEventArgs i delegata zdarzenia jest MouseEventHandler. Należy zauważyć że kilka zdarzeń myszy wspólnej klasy danych zdarzenia i wspólne delegata zdarzenia, więc nazewnictwa schematu pasuje dokładnie Konwencji, opisane powyżej. Zdarzenia myszy modułu obsługi zdarzenia musi mieć następujący podpis:

Sub Mouse_Moved(sender As Object, e As MouseEventArgs)
End Sub

void Mouse_Moved(object sender, MouseEventArgs e){}

void Mouse_Moved(Object^ sender, MouseEventArgs^ e){}

Parametry argument nadawcy i zdarzenia podać dodatkowe szczegóły dotyczące zdarzenia myszy do obsługi zdarzeń. Obiekt nadawca wskazuje, co wywołało zdarzenie. MouseEventArgs parametr zawiera szczegółowe informacje na ruch myszy, która wzbudziła zdarzenia. Wiele źródeł zdarzeń dostarczenie dodatkowych informacji dla zdarzenia i wiele programów obsługi zdarzeń wykorzystanie danych specyficznej dla zdarzenia podczas przetwarzania zdarzenia. Na przykład, który demonstruje podnoszenie i obsługa zdarzeń z danymi specyficznej dla zdarzenia, zobacz jak: podnoszenie i zużywają zdarzenia.

Uwaga

Zdarzenia powstają również poza kontekstem interfejsów użytkownika (UIs), a w rzeczywistości.NET Framework zawiera wiele klas-UI, które uruchamiają zdarzenia.Jednakże wszystkie zdarzenia zgodne ze wzorcem, opisane w tym miejscu.

Informacje o podniesienie zdarzenia z klasy, zobacz Podnoszenie zdarzenie.

Statyczne i dynamiczne zdarzenia

.NET Framework Umożliwia subskrybentom zarejestrować powiadomień o zdarzeniach statycznie lub dynamicznie. Programy obsługi zdarzeń statyczne obowiązują dla całego okresu klasy zdarzeń, których obsługują. Jest to najbardziej typowe metody obsługi zdarzenia. Obsługi zdarzeń dynamicznej są jawnie aktywowane i dezaktywowane podczas wykonywania programu, zazwyczaj w odpowiedzi na niektóre logikę warunkową programu. Na przykład mogą one używane jeśli powiadomienia o zdarzeniach potrzebne są tylko pod pewnymi warunkami lub jeśli aplikacja zawiera procedury obsługi wielu zdarzeń i warunki run-time zdefiniować jeden właściwe, aby użyć.

EventInfo.AddEventHandler Metoda dodaje obsługę zdarzeń dynamicznej i EventInfo.RemoveEventHandler metoda dezaktywuje je. Poszczególne języki także udostępnić swoje własne cechy dynamicznie Obsługa zdarzeń. Poniższy przykład definiuje TemperatureMonitor klasy, który wywołuje TemperatureTheshold zdarzenia w każdym przypadku, gdy temperatura osiągnie próg wstępnie zdefiniowanych. Obsługi zdarzeń, które subskrybuje to zdarzenie jest następnie aktywowane i dezaktywowane podczas wykonywania programu.

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.

Zobacz też

Zadania

Jak: zużywają zdarzeń w aplikacji formularzy sieci Web

Jak: zużywają zdarzeń w aplikacji Windows Forms

Koncepcje

Zdarzenia i pełnomocnicy

Podnoszenie zdarzenie

Inne zasoby

Obsługa i podnoszenie zdarzeń