Efficiency of EventHandlerLis t

[Anders Borum]

Hello!

This post relates to the implementation of the EventHandlerLis t class.

When implementing custom events in a framework I'm developing, a handling of
larger amounts of events in a class was needed and I turned my attention to
the EventHandlerLis t.

For instance, let's imagine I have 16 public events in my class and didn't
use the EventHandlerLis t, the compiler would implement 16 delegates, each
taking approx. 232 bytes (or about 3KB) for each reference (please correct
if this is false), making the storage expensive.

The class that supports these 16 events is provided as a singleton per Http
request. That is, a single instance is instantiated per Http request and all
request during that Http request are given that particular instance. I don't
plan on getting 1000s of hits each second

According to the MSDN documentation, it is recommended to use the
EventHandlerLis t to store your list of delegates as the subscription to the
public events increase (in an adaptive way, so to speak).

From the MSDN documentation on the EventHandlerLis t class:

"This class uses a linear search algorithm to find entries in the list of
delegates. A linear search algorithm is inefficient when working with a
large number of entries. Therefore, when you have a large list, finding
entries is slow."

The linear word gave some concerns so I decompiled the EventHandlerLis t and
saw they are using a linked list. Why not use e.g. a Hashtable? Perhaps
because the Hashtable is a fairly "expensive" object, compared to a simple
linked list?

--
venlig hilsen / with regards
anders borum
--