Como errado é para criar um manipulador de delegado do evento com o padrão (Obj remetente, EventArgs args) assinatura?

Question

Eu entendo os benefícios de usar o evento MS assinatura delegado manipulador padrão, uma vez que permite expandir facilmente na informação passada através do evento com a quebra quaisquer relacionamentos antigos que são baseados no velho assinatura do delegado.

O que eu estou querendo saber é, na prática quantas vezes as pessoas seguem esta regra? Digamos que eu tenha um evento simples como este

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

É um evento simples, e eu sou quase positivo que os únicos argumentos que eu estou sempre indo para necessidade de saber a partir do evento NameChanged é o objeto cujo nome mudou, o nome antigo eo novo nome. Então, vale a pena criar uma classe NameChangedEventArgs separado, ou para eventos simples como este é aceitável para apenas retornar os argumentos diretamente através dos argumentos dos delegados?

Answer 1

Você pode fazer qualquer coisa de forma errada, se você é o único que tem de lidar com ele. Mas não é uma má idéia para aprender padrões e cumpri-los para que você mantenha bons hábitos quando você está trabalhando em código com os outros.

Então, eu vou fazer um trato. Se você prometer fazer isso da maneira certa, eu vou dar-lhe um trecho de código que vai torná-lo muito menos de uma dor. Basta colocar isso em um arquivo .snippet, e colocar esse arquivo em:

Meus Documentos \ Visual Studio 2008 \ trechos de código \ Visual C # \ Meus Trechos de código \
(Ou Visual Studio 2005 se aplicável)

E aqui está o trecho; usá-lo em VS digitando ev2Generic e bater 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

Use o EventHandler<T> representantes genéricos para seus eventos e criar um tipo derivado de EventArgs para armazenar seus dados de eventos. Portanto, em outras palavras, sempre. algo que é que você sempre sabe exatamente como ele funciona quando você se deparar com ela porque ela nunca fez o contrário.

Editar:

CA1003: Use evento genérico casos manipulador
análise de código CA1009: manipuladores de eventos Declare corretamente

Answer 3

Na prática, quantas vezes é que as pessoas [não uso EventArgs classes derivadas].

Eu nunca encontrei um momento em que EventArgs classes derivadas não foram utilizados. Como você diz a si mesmo, ele aumenta a sua capacidade de alterar o código mais tarde. Também gostaria de argumentar que a legibilidade é melhorada, uma vez que é fácil de ver que este é um manipulador de eventos.

Vale a pena criar um separado NameChangedEventArgs classe, ou para eventos simples como este é aceitável para apenas voltar a argumentos diretamente através do delegar argumentos?

Você parece dizer que você usaria EventArgs para manipuladores de eventos com mais params e não usá-lo para casos como este. Honestamente, isso simplesmente não é uma opção ao programar em C #. Consistência é uma obrigação, especialmente no mundo de hoje do fórum é assim, projetos de código aberto, etc, onde é fácil perdê-lo. Claro, se você está programando isso sob uma rocha, você pode fazer o que quiser, mas o # comunidade maior C será obrigado por seguir padrões e, especialmente, usando consistência em você código.