Generische Ereignishandlerinstanzen verwenden

Ursache

Ein Typ enthält einen Delegaten, der void zurückgibt. Die zugehörige Signatur enthält zwei Parameter (der erste ist ein Objekt, der zweite ein Typ, der EventArgs zugewiesen werden kann), und die enthaltende Assembly hat .NET Framework 2.0 zum Ziel.

Regelbeschreibung

Bei dieser Regel wird davon ausgegangen, dass ein Delegat, dessen Name mit "EventHandler" endet, die Signatur einer Ereignisbehandlungsmethode definiert. Vor .NET Framework 2.0 musste ein neuer Delegat deklariert werden, der eine von der System.EventArgs-Klasse abgeleitete Klasse angab, damit an den Ereignishandler benutzerdefinierte Informationen übergeben werden konnten. Dies ist in .NET Framework 2.0 nicht mehr erforderlich, da der System.EventHandler-Delegat eingeführt wurde. Dieser generische Delegat lässt zu, dass jede von EventArgs abgeleitet Klasse mit dem Ereignishandler verwendet werden kann.

Behandlung von Verstößen

Um einen Verstoß gegen diese Regel zu beheben, entfernen Sie den Delegaten und ersetzen die zugehörige Instanz durch den System.EventHandler-Delegaten. Wenn der Delegat automatisch durch den Visual Basic-Compiler generiert wird, ändern Sie die Syntax der Ereignisdeklaration so, dass der System.EventHandler-Delegat verwendet wird.

Warnungsausschluss

Schließen Sie keine Warnung dieser Regel aus.

Beispiel

Im folgenden Beispiel wird ein Delegat veranschaulicht, der gegen die Regel verstößt. Im Visual Basic-Beispiel beschreiben Kommentare, wie das Beispiel geändert wird, damit die Regel eingehalten wird. Für C# wird ein Beispiel mit geändertem Code angezeigt.

Imports System

Namespace DesignLibrary

   Public Class CustomEventArgs
      Inherits EventArgs

      Public info As String = "data"

   End Class

   Public Class ClassThatRaisesEvent
   
      ' This statement creates a new delegate, which violates the rule.
      Event SomeEvent(sender As Object, e As CustomEventArgs)

      ' To satisfy the rule, comment out the previous line 
      ' and uncomment the following line.
      'Event SomeEvent As EventHandler(Of CustomEventArgs)

      Protected Overridable Sub OnSomeEvent(e As CustomEventArgs)
            RaiseEvent SomeEvent(Me, e)
      End Sub

      Sub SimulateEvent()
         OnSomeEvent(New CustomEventArgs())
      End Sub

   End Class

   Public Class ClassThatHandlesEvent
   
      Sub New(eventRaiser As ClassThatRaisesEvent)
         AddHandler eventRaiser.SomeEvent, AddressOf HandleEvent
      End Sub

      Private Sub HandleEvent(sender As Object, e As CustomEventArgs)
         Console.WriteLine("Event handled: {0}", e.info)
      End Sub

   End Class

   Class Test
   
      Shared Sub Main()

         Dim eventRaiser As New ClassThatRaisesEvent()
         Dim eventHandler As New ClassThatHandlesEvent(eventRaiser)

         eventRaiser.SimulateEvent()

      End Sub

   End Class

End Namespace

using System;

namespace DesignLibrary
{
   // This delegate violates the rule.
   public delegate void CustomEventHandler(
      object sender, CustomEventArgs e);

   public class CustomEventArgs : EventArgs
   {
      public string info = "data";
   }

   public class ClassThatRaisesEvent
   {
      public event CustomEventHandler SomeEvent;

      protected virtual void OnSomeEvent(CustomEventArgs e)
      {
         if(SomeEvent != null)
         {
            SomeEvent(this, e);
         }
      }

      public void SimulateEvent()
      {
         OnSomeEvent(new CustomEventArgs());
      }
   }

   public class ClassThatHandlesEvent
   {
      public ClassThatHandlesEvent(ClassThatRaisesEvent eventRaiser)
      {
         eventRaiser.SomeEvent += 
            new CustomEventHandler(HandleEvent);
      }

      private void HandleEvent(object sender, CustomEventArgs e)
      {
         Console.WriteLine("Event handled: {0}", e.info);
      }
   }

   class Test
   {
      static void Main()
      {
         ClassThatRaisesEvent eventRaiser = new ClassThatRaisesEvent();
         ClassThatHandlesEvent eventHandler = 
            new ClassThatHandlesEvent(eventRaiser);

         eventRaiser.SimulateEvent();
      }
   }
}

Im folgenden Beispiel wird die Delegatendeklaration aus dem vorherigen Beispiel entfernt, wodurch die Regel eingehalten wird, und die zugehörige Instanz in der ClassThatRaisesEvent-Methode und der ClassThatHandlesEvent-Methode wird durch denSystem.EventHandler-Delegaten ersetzt.

using System;

namespace DesignLibrary
{
   public class CustomEventArgs : EventArgs
   {
      public string info = "data";
   }

   public class ClassThatRaisesEvent
   {
      public event EventHandler<CustomEventArgs> SomeEvent;

      protected virtual void OnSomeEvent(CustomEventArgs e)
      {
         if(SomeEvent != null)
         {
            SomeEvent(this, e);
         }
      }

      public void SimulateEvent()
      {
         OnSomeEvent(new CustomEventArgs());
      }
   }

   public class ClassThatHandlesEvent
   {
      public ClassThatHandlesEvent(ClassThatRaisesEvent eventRaiser)
      {
         eventRaiser.SomeEvent += 
            new EventHandler<CustomEventArgs>(HandleEvent);
      }

      private void HandleEvent(object sender, CustomEventArgs e)
      {
         Console.WriteLine("Event handled: {0}", e.info);
      }
   }

   class Test
   {
      static void Main()
      {
         ClassThatRaisesEvent eventRaiser = new ClassThatRaisesEvent();
         ClassThatHandlesEvent eventHandler = 
            new ClassThatHandlesEvent(eventRaiser);

         eventRaiser.SimulateEvent();
      }
   }
}

Verwandte Regeln

Übermäßige Anzahl von Parametern in generischen Typen vermeiden

Auflistungen müssen eine generische Schnittstelle implementieren

Statische Member nicht in generischen Typen deklarieren

Generische Listen nicht verfügbar machen

Generische Typen in Membersignaturen nicht schachteln

Generische Methoden müssen den Typparameter angeben

Nach Möglichkeit Generika verwenden

Siehe auch

Konzepte

Generika (C#-Programmierhandbuch)