-1

According to the accepted answer here there is no difference, but in MSDN:

Typically, you do not have to declare a delegate for an event, because you can use either the EventHandler or the EventHandler<TEventArgs> delegate. You should declare a delegate only in rare scenarios, such as making your class available to legacy code that cannot use generics.

So it seems to me that Microsoft highly recommend the generic approach over the simplified and less typing one, but I cannot figure out why or what is the difference?

Community
  • 1
  • 1
mshwf
  • 7,009
  • 12
  • 59
  • 133
  • 2
    You misunderstood the question, it was about `EventHandler`. Point is that you can use the generic to declare your own `EventHandler` where Something is your own class derived from EventArgs that has properties you want to pass to the event subscriber. Which is *not* the same as the non-generic EventHandler, it doesn't allow passing properties. – Hans Passant May 01 '17 at 22:04

2 Answers2

1

I believe both the accepted answer and the MSDN documentation you link to state the same thing, to use either EventHandler or EventHandler<"T"> (the less typing one) instead of creating your own custom delegates.

From the accepted answer: "...you should probably prefer the former over the latter because it's clearer and requires less typing."
The former being: 

public event EventHandler<MyEventArgs> SomeEvent;

And from MSDN: For scenarios where the EventHandler and EventHandler<"TEventArgs"> delegates do not work, you can define a delegate.
Defining a delegate is the 'latter' from the accepted answer:

public delegate void MyEventHandler(object sender, MyEventArgs e);
Gregg L
  • 380
  • 1
  • 6
  • 16
-1

In my opinion, as soon as EventHandler<MyEventArgs> occurs at least twice in your project, you have produced hard-to-maintain copy & paste code:

public event EventHandler<MyEventArgs> ItemBeginningEdit;
public event EventHandler<MyEventArgs> ItemCommited;
public event EventHandler<MyEventArgs> ItemEditCancelled;
...

In order to keep your code clean, you should abstract the event handler type by defining your own MyEventHandler delegate in this case. If you later want to switch from let's say MyEventArgs to MyEventArgs2, you only have to change it in one single place:

public delegate void MyEventHandler(object sender, MyEventArgs2 e);
public event MyEventHandler ItemBeginningEdit;                ^
public event MyEventHandler ItemCommited;                     |
public event MyEventHandler ItemEditCancelled;                |
...
Kim Homann
  • 3,042
  • 1
  • 17
  • 20
  • 1
    This is only a problem, if you frequently need to update the delegate. I find it in my case, the most common situation is to update the `MyEventArgs` class instead. – Adam L. S. Nov 30 '21 at 08:57