Performance implications of .net Events

Question

We were having a discussion at the office on how to solve a particular problem and using an event was raised (no pun intended). The response was negative citing misuse and that they can be expensive.

I understand the concerns behind misuse and I know that they are just a special multicast delegate but given a scenario where there is at most one listener why would using an event over a method call be considered "expensive"?

Update:

Just to be clear this is not about any particular implementation this is a more general question about the cost of using an event over a method call.

Answer 1

In .NET 2.0 calling a delegate is just as fast as an interface method call. They even seem to be a bit faster.

But even if the overhead were 10x higher, I doubt delegate calls would ever be the speed bottleneck in your application. Use a profiler if you want to find the real bottlenecks.

edit in response to the claim that events are slower than delegates: In fact, events are delegates. This code shows that their performance is identical, at least on my machine.

Answer 2

Test it in your scenario - I would imagine that many, many factors can affect this, especially when we're talking something with such a low relative cost as a method/delegate call.

A quick and simple test with a release build not under a debugger, compiled under 4.0 as "any cpu", and running on 64-bit windows 7:

Another Edit: Oops Here's a better result. See the code for how it's working

10000000 direct reference calls     :   0.011 s
10000000 calls through an interface :   0.037 s
10000000 invocations of an event    :   0.067 s
10000000 calls through Action<int>  :   0.035 s

So in a straight "do nothing test" with ten million calls, an event adds .474 sec [edit, only .026 now on a much better machine, still roughly double however]

I would worry more about correctness of design than half a second every 10 million calls, unless you are expecting to do that many calls in short periods of time (in which case perhaps there is a more fundamental design issue).

Answer 3

Performance is definitely not something you should concern yourself about. You're talking about nanoseconds here. If you have just one listener, there is no difference at all.

I would simply consider what makes more sense in your application, using events or calling a method and choose the best option. The main difference being that an object A generating events doesn't have to know its listener(s). The same object A calling a method has to know the instance to call it from. Where do you want to put the dependency?