event vs method override

[bhavin]

Hi,
Can someone point me to some good best practices kind of documentation on
use of events compared to method overriding.
Ex. In Windows Forms when should i have an event handler for Paint, and when
should i override OnPaint?

I have to implement added functionality in a child class, and am in two
minds .. to have the parent fire an event, or make the method virtual and
override in the child. Am hoping some reading with description of various
scenerios will increase my understanding and eventually help me make the
decision.

thanx in advance
-bh

[John Wood]

I can't think of a document, sorry.
But I can give you my opinion.

Choosing to use an override forces your user to inherit from the class, so
only choose override as an option when you'd be expecting the user to
customize the behavior of your class (which itself isn't generally a very
common thing) by modifying what would normally be implementation details of
your class.

Choose events when you want to notify of something so they can potentially
go off and do something else, consider situations where more than one object
may subscribe to the event, something which isn't possible with overrides.

--
John Wood
Blog: http://spaces.msn.com/members/johnwood/
"bhavin" <[e-mail] > wrote in message
news:eS******** ******@TK2MSFTN GP10.phx.gbl...

Hi,
Can someone point me to some good best practices kind of documentation on
use of events compared to method overriding.
Ex. In Windows Forms when should i have an event handler for Paint, and when should i override OnPaint?

I have to implement added functionality in a child class, and am in two
minds .. to have the parent fire an event, or make the method virtual and
override in the child. Am hoping some reading with description of various
scenerios will increase my understanding and eventually help me make the
decision.

thanx in advance
-bh

[Richard Blewett [DevelopMentor]]

There are two crucial differences between overriding and adding an event handler

1) To override you need to be a derived class (obviously) whereas anyone can add an event handler to a control.

2) The base class version of these virtual methods fires the event handlers. So if you need to layer in code in a specific place relative to when the event handlers fire (before or after) overriding is the only sure-fire way of doing this. The Paint event is a great example of this. Normally, people add a paint event handler to "decorate" your control from its standard appearance. You need to make sure the control paints it's appearance before the event handlers run otherwise you will draw over the top of the decorations. So the folllowing is the standard pattern for a custom control

protected override void OnPaint(PaintEv entArgs e)
{
// Do your custom painting here

base.OnPaint(e) ; // this fires thte event handlers
}

Regards

Richard Blewett - DevelopMentor
http://www.dotnetconsult.co.uk/weblog
http://www.dotnetconsult.co.uk

Hi,
Can someone point me to some good best practices kind of documentation on
use of events compared to method overriding.
Ex. In Windows Forms when should i have an event handler for Paint, and when
should i override OnPaint?

I have to implement added functionality in a child class, and am in two
minds .. to have the parent fire an event, or make the method virtual and
override in the child. Am hoping some reading with description of various
scenerios will increase my understanding and eventually help me make the
decision.

thanx in advance
-bh

[carl.manaster]

http://www.bobpowell.net/overrideorhandle.htm

Peace,
--Carl

[carl.manaster]

http://www.bobpowell.net/overrideorhandle.htm

Peace,
--Carl

[bhavin]

My client class IS a child of the main class. We are building a forms
framework, which acts as a core for the individual forms (which also will be
created by us). So the form class in the final form assembly is inherited
from the framework form class.

I was hoping to get various usecases which will help me decide, depending on
which usecase i can relate to.
Though it is a child class i am leaning towards using events for this
specific case.

-bh
"John Wood" <sp**@isannoyin g.com> wrote in message
news:uo******** ******@TK2MSFTN GP10.phx.gbl...

I can't think of a document, sorry.
But I can give you my opinion.

Choosing to use an override forces your user to inherit from the class, so
only choose override as an option when you'd be expecting the user to
customize the behavior of your class (which itself isn't generally a very
common thing) by modifying what would normally be implementation details of your class.

Choose events when you want to notify of something so they can potentially
go off and do something else, consider situations where more than one object may subscribe to the event, something which isn't possible with overrides.

--
John Wood
Blog: http://spaces.msn.com/members/johnwood/
"bhavin" <[e-mail] > wrote in message
news:eS******** ******@TK2MSFTN GP10.phx.gbl...

Hi,
Can someone point me to some good best practices kind of documentation on use of events compared to method overriding.
Ex. In Windows Forms when should i have an event handler for Paint, and

when

should i override OnPaint?

I have to implement added functionality in a child class, and am in two
minds .. to have the parent fire an event, or make the method virtual and override in the child. Am hoping some reading with description of various scenerios will increase my understanding and eventually help me make the
decision.

thanx in advance
-bh

[bhavin]

Thanks Carl for the link.
Its an interesting article and Bob end it with
" Generally, if you are deriving from a control, always override. A control
should never handle it's own events because to do so can seriously effect
the rules of object-orientation. "
Would experts here maintain the same opinion about controls, and other
non-control inherited classes?
It kinda makes me think about my idea of using events in a child class to
extend more functionality.

-bh

<ca***********@ gmail.com> wrote in message
news:11******** **************@ c13g2000cwb.goo glegroups.com.. .

http://www.bobpowell.net/overrideorhandle.htm

Peace,
--Carl

[Jay B. Harlow [MVP - Outlook]]

bh,
I tend to view events as external to the class, they are used to notify
other objects that something interesting happened to this object.

While Overridable methods are internal to the class, they are used to notify
base or derived classes (the object itself) that something interesting
happened to the object (itself).

I don't have the specific reference on MSDN however I distinctly remember
reading that calling an overridable method will be faster then raising an
event.

The following mention using the override instead of the event:

http://msdn.microsoft.com/library/de...Guidelines.asp

http://msdn.microsoft.com/library/de...Guidelines.asp

The first link mentions "The purpose of the method is to provide a way for a
derived class to handle the event using an override. This is more natural
than using delegates in situations where the developer is creating a derived
class".

It may have been in this article, however I am not seeing it right now:
http://msdn.microsoft.com/library/de...l/scalenet.asp

Hope this helps
Jay

"bhavin" <[e-mail] > wrote in message
news:en******** ******@TK2MSFTN GP14.phx.gbl...

Thanks Carl for the link.
Its an interesting article and Bob end it with
" Generally, if you are deriving from a control, always override. A
control
should never handle it's own events because to do so can seriously effect
the rules of object-orientation. "
Would experts here maintain the same opinion about controls, and other
non-control inherited classes?
It kinda makes me think about my idea of using events in a child class to
extend more functionality.

-bh

<ca***********@ gmail.com> wrote in message
news:11******** **************@ c13g2000cwb.goo glegroups.com.. .

http://www.bobpowell.net/overrideorhandle.htm

Peace,
--Carl

[Richard Blewett [DevelopMentor]]

In terms of Windows Forms controls the speed argument is a total red herring - how about a click event

1) there is a user involved - and so they are thinking
2) they decide to click the mouse - to actually do this will take a reasonable amount of time (milliseconds?)
3) there is a hardware interrupt as the mouse click is received
4) the mouse click has to make it from Kernel mode to User mode and be *posted* to the relevent windows message queue
5) the message pump picks up the message and dispatches it to the windows procedure

The small number of machine instructions difference between virtual and delegate based dispatch is lost in the noise. The crucial thing is the ability to layer in code relative to event firing.

Regards

Richard Blewett - DevelopMentor
http://www.dotnetconsult.co.uk/weblog
http://www.dotnetconsult.co.uk

I don't have the specific reference on MSDN however I distinctly remember
reading that calling an overridable method will be faster then raising an
event.

[Jay B. Harlow [MVP - Outlook]]

Richard,

The crucial thing is the ability to layer in code relative to event
firing. I'm not specifically sure what you mean here.
I agree the "speed" argument is largely a red herring, especially in the UI.
(the 80/20 rule).

However! My main point was not about speed, the main point I was attempting
to make was about internal verses external notification!

Although I did not mention I also agree with the design guidelines, using
the override for derived classes is "more natural", being "more natural" is
also more important then performance (again the 80/20 rule)...

Jay
"Richard Blewett [DevelopMentor]" <ri******@NOSPA Mdevelop.com> wrote in
message news:uE******** ******@TK2MSFTN GP10.phx.gbl... In terms of Windows Forms controls the speed argument is a total red
herring - how about a click event

1) there is a user involved - and so they are thinking
2) they decide to click the mouse - to actually do this will take a
reasonable amount of time (milliseconds?)
3) there is a hardware interrupt as the mouse click is received
4) the mouse click has to make it from Kernel mode to User mode and be
*posted* to the relevent windows message queue
5) the message pump picks up the message and dispatches it to the windows
procedure

The small number of machine instructions difference between virtual and
delegate based dispatch is lost in the noise. The crucial thing is the
ability to layer in code relative to event firing.

Regards

Richard Blewett - DevelopMentor
http://www.dotnetconsult.co.uk/weblog
http://www.dotnetconsult.co.uk

I don't have the specific reference on MSDN however I distinctly
remember
reading that calling an overridable method will be faster then raising an
event.