C# Handling Events

When I deal set up events, I usually write as such:

data.event += new data.returndataeventhandler(method);

And have a method as such:

void method(parameter)
{
   dosomething();
}

This is when the event returns an object.

I have just been reading through somebody elses code and they have used, what seems to be 开发者_开发问答a much cleaner way, as such:

data.ReturnData += delegate(DataSet returnedDataSet)
                                    {
                                        dataset = returnedDataSet;
                                    };

Is there any downfall to this way?

Thanks.

The one major downfall of using anonymous delegates (or the even-cleaner Lambda as suggested by tster) is that you're not going to be able to unsubscribe it from the event later unless you give it some sort of name.

In most cases, this is "No Big Deal (tm)" because the delegate will go away whenever the event source goes away, but this can be a "Subtle Mistake (tm)" if you're subscribing to static events or events on long-lived objects (e.g., the WPF Dispatcher object).

In your case, this doesn't look like a problem at all, so I'd definitely recommend going with tster's recommendation (assuming you're using an appropriately recent version of .Net):

data.ReturnData += returnedDataSet => dataset = returnedDataSet;

(The compiler can infer the type of returnedDataSet from the EventHandler type of ReturnData.)

The primary downfall of using anonymous delegates is that they are not reusable. Other than that there is typically no difference between defining a delegate and then using it elsewhere in your code versus using an anonymous delegate.

One down fall is that it will not appear in your method drop down list. If you do it inline, it should only be simple, nothing overly complex.

Like said by others, the most obvious is not reusable. Other points:

• readability in particular if you have large method body
• because .NET generate a random name for anonymous method (not very meaningful or readable) if you use reflection type technology or profiler, it may complicate traceability.

The only downfall is that if you have more than one event it's easier to point it to a method. If you had to attach events in different blocks to the same handler, you would have to store your delegate somewhere so that both blocks could "see" it.

Even cleaner:

data.ReturnData += returnedDataSet => dataset = returnedDataSet;

Nope its just anonymous method thats all. You can read more about anonymous methods here.

Aside from the other answers of reusablity/Intellisense, I believe the only downfall is if you need to remove the handler later. With a delegate/lamba you cannot easily remove your handler if it no longer needs to be called.