Wie falsch ist es ein Event-Handler delegieren mit aus dem Standard (Obj sender, EventArgs args) Signatur zu erstellen?

Question

verstehe ich die Vorteile der Standard-MS-Ereignishandler Delegat-Signatur, wie es Ihnen auf die Informationen leicht erweitern ermöglicht durch das Ereignis übergeben mit heraus alle alten Beziehungen zu brechen, die auf dem alten Delegierten Signatur basieren.

Was ich frage mich, ist in der Praxis, wie oft Menschen haben diese Regel? Sagen, dass ich ein einfaches Ereignis wie dieses haben

public event NameChangedHandler NameChanged;
public delegate void NameChangedHandler(Object sender, string oldName, string newName);

Es ist ein einfaches Ereignis, und ich bin fast positiv, dass die einzigen Argumente, die ich jemals wissen müssen, werde von der NameChanged Ereignis das Objekt, dessen Name geändert, der alte Name, und der neue Name. So lohnt es sich eine separate NameChangedEventArgs Klasse zu erstellen, oder für einfache Veranstaltungen wie diese es akzeptabel ist, einfach direkt die Argumente zurückkehren durch die Delegierten Argumente?

Answer 1

Sie können die falsche Art und Weise alles tun, wenn du der einzige bist, der mit ihm zu tun hat. Aber es ist keine schlechte Idee, Standards zu lernen und bei ihnen zu bleiben, so dass Sie gute Gewohnheiten halten, wenn Sie mit anderen auf Code arbeiten.

So werde ich Ihnen ein Geschäft machen. Wenn Sie es zu tun, den richtigen Weg versprechen, werde ich Ihnen einen Code-Schnipsel geben, dass es viel weniger ein Schmerz machen werde. setzen diese nur in einer .snippet-Datei, und legen Sie die Datei in:

Eigene Dateien \ Visual Studio 2008 \ Code Snippets \ Visual C # \ My Code Snippets \
(Oder Visual Studio 2005, wenn zutreffend)

Und hier ist das Snippet; verwenden Sie es in VS durch ev2Generic eingeben und schlagen Tab:

<?xml version="1.0" encoding="utf-8" ?>
<CodeSnippets  xmlns="http://schemas.microsoft.com/VisualStudio/2005/CodeSnippet">
  <CodeSnippet Format="1.0.0">
    <Header>
      <Title>Generic event with two types/arguments.</Title>
      <Shortcut>ev2Generic</Shortcut>
      <Description>Code snippet for event handler and On method</Description>
      <Author>Kyralessa</Author>
      <SnippetTypes>
        <SnippetType>Expansion</SnippetType>
      </SnippetTypes>
    </Header>
    <Snippet>
      <Declarations>
        <Literal>
          <ID>type1</ID>
          <ToolTip>Type of the first property in the EventArgs subclass.</ToolTip>
          <Default>propertyType1</Default>
        </Literal>
        <Literal>
          <ID>arg1Name</ID>
          <ToolTip>Name of the first argument in the EventArgs subclass constructor.</ToolTip>
          <Default>property1Name</Default>
        </Literal>
        <Literal>
          <ID>property1Name</ID>
          <ToolTip>Name of the first property in the EventArgs subclass.</ToolTip>
          <Default>Property1Name</Default>
        </Literal>
        <Literal>
          <ID>type2</ID>
          <ToolTip>Type of the second property in the EventArgs subclass.</ToolTip>
          <Default>propertyType2</Default>
        </Literal>
        <Literal>
          <ID>arg2Name</ID>
          <ToolTip>Name of the second argument in the EventArgs subclass constructor.</ToolTip>
          <Default>property2Name</Default>
        </Literal>
        <Literal>
          <ID>property2Name</ID>
          <ToolTip>Name of the second property in the EventArgs subclass.</ToolTip>
          <Default>Property2Name</Default>
        </Literal>
        <Literal>
          <ID>eventName</ID>
          <ToolTip>Name of the event</ToolTip>
          <Default>NameOfEvent</Default>
        </Literal>
      </Declarations>
      <Code Language="CSharp">
        <![CDATA[public class $eventName$EventArgs : System.EventArgs
      {
        public $eventName$EventArgs($type1$ $arg1Name$, $type2$ $arg2Name$)
        {
          this.$property1Name$ = $arg1Name$;
          this.$property2Name$ = $arg2Name$;
        }

        public $type1$ $property1Name$ { get; private set; }
        public $type2$ $property2Name$ { get; private set; }
      }

      public event EventHandler<$eventName$EventArgs> $eventName$;
            protected virtual void On$eventName$($eventName$EventArgs e)
            {
                var handler = $eventName$;
                if (handler != null)
                    handler(this, e);
            }]]>
      </Code>
    </Snippet>
  </CodeSnippet>
</CodeSnippets>

Answer 2

Mit den EventHandler<T> generischen Delegaten für Ihre Veranstaltungen und eine Art von EventArgs abgeleitet erstellen Sie Ihre Ereignisdaten zu halten. Also mit anderen Worten, immer. Es ist etwas, das Sie immer genau wissen, wie es funktioniert, wenn Sie über sie kommen, weil es sonst nie getan hat.

Edit:

Code-Analyse CA1003: Verwenden Sie generische Ereignishandler Instanzen
Codeanalyse CA1009: Event-Handler Declare korrekt

Answer 3

  

In der Praxis, wie oft tun Menschen [nicht   verwenden EventArgs abgeleitete Klassen].

Ich habe noch nie begegnet eine Zeit, als EventArgs abgeleitete Klassen nicht verwendet wurden. Wie Sie selbst sagen, es erhöht Ihre Fähigkeit, später den Code zu ändern. Ich würde auch argumentieren, dass die Lesbarkeit verbessert wird, da es leicht zu sehen, dass dies ein Event-Handler.

  

Lohnt es sich eine separate zu erstellen   NameChangedEventArgs Klasse oder für   einfache Veranstaltungen wie diese ist es   akzeptabel nur die Rückkehr   Argumente direkt durch die   Delegierten Argumente?

Sie scheinen zu sagen, dass Sie EventArgs für Event-Handler mit mehr params und nicht verwenden es für Fälle wie diese verwenden würde. Ehrlich gesagt, das ist einfach keine Option, wenn in C # programmieren. Konsistenz ist ein Muss, vor allem in der heutigen Welt des Forum wie diese, Open-Source-Projekte, etc. wo es leicht, es zu verlieren. Sicher, wenn Sie diese unter einem Felsen programmieren, können Sie tun, was Sie wollen, aber die größere C # Gemeinschaft wird es Ihnen danken für Normen folgen und vor allem in Sie Code Konsistenz.