Is it possible to create basic event handler for many pages with user control or master page?

Question

I need to create general actions menu for my pages. All of pages will implement some basical functionality, i.e adding new rows to some table, editing them, calling filters. Many of this pages will need only basical logic to run this functionality. But some of the pages will implement their own logic for options in menu.

I want to make this happen by using events in menu. So I'll need not the only events, but some basic event handler for all pages. And this handler schould be constructed in a way it could be overriden. The problem is I don't know how to create handler for all future uses of menu. Sounds kind of utopic in some way. Is it real to create architecture like this?

I thought about two ways of doing this: Master page or user control. But I don't really know if it's even possible. So what do you think?

UPD: Upvoted both answers about basic pages: you guys are surely know what you're talking about. Thanks. Sorry that right answer can be selected only once.

Answer 1

I think that to "create handler for all future uses" sounds scary.

What I would do was to create the pages individually, and only when I identify some piece of logic that is equal or similar I would refactor that out to a separate class that several forms could use.

After all, code needs to be used before it can be reused.

Answer 2

You really shouldn't instantiate objects on pages unnecessarily, as this approach would most certainly do.

Keeping that in mind, you can make a base page that relevant pages inherit from, so you have access to the methods you need.

1. Create a class of type System.Web.UI.Page. (Let's name it MyBasePageClass)
2. Implement common methods needed in this class
3. Inherit this class on the pages you need to expose the methods to. For example, change your definition of the Default.aspx page class to this: public partial class Default : MyBasePageClass

The methods created in MyBasePageClass must be public to be seen by Default.aspx.cs.

Answer 3

In many of my applications, I use a common base class if I have functionality to share across many pages. It's not uncommon practice, really.

The implementation might look something like this:

public class MyApplicationPage : System.Web.UI.Page
{
    public virtual void RaiseMyCustomEvent(EventArgs e)
    {
    }
}

The virtual keyword makes the method overridable.

In my individual code behinds, the page inheritance might look like this:

public partial class MyPage : MyApplicationPage
{
    public override void RaiseMyCustomEvent(EventArgs e)
    {
        // ...
    }
}

Finally, in my master page, I might find code like this in a method:

if (Page is MyApplicationPage)
{
    ((MyApplicationPage)Page).RaiseMyCustomEvent(EventArgs.Empty);
}