C#: Using event handlers vs overriding event-firing methods

Question

I am creating a subclass of Button and would like to add custom functionality to some of its events such as OnClick. Which is the more desirable way to do it? Do I override OnClick:

protected override void OnClick(EventArgs e)
{
    base.OnClick(e);
    doStuff();
}

or should I instead link up the OnClick event to an event handler defined in my Button subclass through the designer?

class ButtonSubclass
{
    public ButtonSubclass() : base()
    {
        InitializeComponent();
    }

    private void InitializeComponent()
    {
        this.Click += new System.EventHandler(this.ButtonSubclass_Click);
    }
}

Edit: I added minor visual changes (that may pass as rudimentary skinning) but most of the changes are in event handlers that I don't want to re-implement (copy-paste) on every form that reuses it.

Answer 1

Always override OnClick when inheriting. It gives you better performance.

Answer 2

If you're genuinely specializing the button, it makes sense to override OnClick. If you're only actually changing what happens when a button is clicked, I wouldn't subclass Button in the first place - I'd just add event handlers.

EDIT: Just to give a bit more of an idea - if you want to add similar event handlers for multiple buttons, it's easy enough to write a utility method to do that, and call it from multiple places. It doesn't require actual subclassing. That's not to say subclass is definitely wrong in your case, of course - just giving you extra options :)

Answer 3

For a button click, I'd keep it as a method for reading. But I guess it is a personal preference thing. I'd be interested to see what the concensus is.

Answer 4

From an object oriented perspective it's better to minimize the use of events (most Java folks survive without delegates and events :) )

maybe a bit offtopic, nut in ASP.NET, I always override the methods (like OnLoad) rather than using the event handlers (Page_Load) to prevent "AutoEventWireUp" confusion.

I normally like to disable "AutoEventWireUp" completely because it works very non-transparent but in the case where someone enables it again you might end up with duplicate handlers, causing them to be fired twice.

I guess for Windows Forms it's also more transparent to override methods, as it doesn't involve the risk of accidentally adding multiple event handlers, and I dislike the camelCased underscore (_) syntax of automatically created handlers.