EventHandler和ElapsedEventHandler之间有什么区别？

Question

So far in my limited use of c# I've subscribed to a couple of events. Why do the following two code snippets use two diferent words EventHandler and ElapsedEventHandler ?

        myProcess = new Process();
        myProcess.StartInfo.FileName = @"notepad.exe";
        myProcess.Exited += new EventHandler(MyProcessExited);

compared to:

        myTimer = new System.Timers.Timer(tickLength);
        myTimer.Elapsed += new ElapsedEventHandler(myTimer_Elapsed);

are these words EventHandler and ElapsedEventHandler specific to the object whose event I'm using? Or are there a whole set of objects where I have to use "EventHandler" and different set of objects where I have to use "ElapsedEventHandler" ? (ie for set X of objects we use xxxxxEventHandler etc)

Answer 1

Are these words EventHandler and ElapsedEventHandler specific to the object whose event I'm using?

This words are names of delegates. And they are specific to information, which is passed from object, which raised event to subscribers of that event. Read about events, delegates and parameters passing below.

An event in C# is a way for a class to provide notifications to clients of that class when some interesting thing happens to an object. Events are declared using delegates .

So, if you want to notify client of some interesting thing happened in your object, you can declare delegate:

public delegate void SomethingHappenedDelegate();

And declare event of this type in your class:

class Foo
{
    public event SomethingHappenedDelegate SomethingHappened;

    // other code, which raises SomethingHappened event
    // when something interesting happened
}

When clients of this class want to be notified that something interesting happenedthey should subscribe to SomethingHappened event. And event handler signature must match type of event (SomethingHappenedDelegate in this case):

static void Main(string[] args)
{
    Foo foo = new Foo();
    foo.SomethingHappened += new SomethingHappenedDelegate(Foo_SomethingHappened);            
}

// this method should be: void MethodName()
static void Foo_SomethingHappened()
{
    // you notified, that something happened
}

When you need to pass some additional data when notifying clients, you should use different delegate type, which takes some arguments. For example, if you want to pass some message to clients, change event's delegate type:

public delegate void SomethingHappenedDelegate(string message);

Now you should change event handler to correspond this delegate type:

static void Foo_SomethingHappened(string message)
{
    // you notified, that something happened and you recieved a message
}

Another example, if we want to pass instance of object, which raised an event, and some additional arguments message and time:

public delegate void SomethingHappenedDelegate(object sender, string message, DateTime time);

Then we should have event handler with same signature:

static void Main(string[] args)
{
    Foo foo1 = new Foo();
    foo1.SomethingHappened += new SomethingHappenedDelegate(Foo_SomethingHappened);
    Foo foo2 = new Foo();
    foo2.SomethingHappened += new SomethingHappenedDelegate(Foo_SomethingHappened); 
}

// we use same event handler for all SomethingHappened events
static void Foo_SomethingHappened(object sender, string message, DateTime time)
{
    Foo foo = sender as Foo; // now we get object, which raised event
    // and we can use message and time
}

So, all events have type of some delegate. Definition of that delegate describes which parameters should receive method, which will be handling event. In your code you use two events - Process.Exited and Timer.Elapsed . Lets look how these events defined:

public event EventHandler Exited;
public event ElapsedEventHandler Elapsed;

You can see here different types of delegates:

public delegate void EventHandler(object sender, EventArgs e);
public delegate void ElapsedEventHandler(object sender, ElapsedEventArgs e);

As you can see from definition, these delegates have same first parameter (sender), and different last parameter. So, handlers of these events also should have different signature, which should match these delegates.

You may wonder, why name of second parameter ends with EventArgs. If you want to notify other objects, that SomethingHappened, then following convention exists in C#:

• event name should be SomethingHappened
• if clients need some additional data to be passed, these data encapsulated in object, which derives from EventArgs class: SomethingHappenedEventArgs .
• event delegate should be EventHandler (if no additional info should be passed to clients), or it should be of generic type EventHandler <SomethingHappenedEventArgs> , or it should be custom delegate with name SomethingHappenedEventHandler and signature void (object sender, SomethingHappenedEventArgs e)

Read more here .

Answer 2

No, the event names are matter of framework designer choice + they are toughly coupled to delegates that rapresent the event of any specific object.

EventHandler defininton is:

[Serializable]
[ComVisible(true)]
public delegate void EventHandler(object sender, EventArgs e);

ElapsedEventHandler definiton is:

public delegate void ElapsedEventHandler(object sender, ElapsedEventArgs e);

As you can see they are different delegate types.