Sponsored By Aspose - File Format APIs for .NET

Aspose are the market leader of .NET APIs for file business formats – natively work with DOCX, XLSX, PPT, PDF, MSG, MPP, images formats and many more!

ASP.NET Page Inheritance – Base Page Classes in your Web Applications

A week ago I talked about using XML Serialization as a means to persist and retrieve application settings.  Using that example as a stepping stone, I want to extend this idea further by exposing these settings via a base ASP.NET page class for use in your web applications.

In general, base page classes in your web applications help you to remove code smells in your web applications by allowing you to “Move Up” or “Pull Up” code that is common to all your web pages.  Often, accessing application settings is one such action you do in all your web pages and is better exposed via a base page class.

I am going to take the same SiteSettings Class we used before and just expand the static methods a bit more to include saving the configuration in cache with a dependency on our sitesettings.config file in the application directory.  This will improve performance so we don’t have to access the application settings from the file each time, but also have the application settings refreshed when a change is detected in the underlying file.


SiteSettings Class
public class SiteSettings
#region Private Members

private string _name;
private string _url;
private string _emailAddress;


#region Properties

public string Name
get { return _name; }
set { _name = value; }

public string Url
get { return _url; }
set { _url = value; }

public string EmailAddress
get { return _emailAddress; }
set { _emailAddress = value; }


public SiteSettings() {}

#region Static Methods

public static SiteSettings Fetch()
if (HttpContext.Current.Cache[SiteSettings] != null)
return (SiteSettings)HttpContext.Current.Cache[SiteSettings];
SiteSettings settings
= SiteSettings.FetchFromFile();
SiteSettings, settings,
new CacheDependency(HttpContext.Current.Server.MapPath(sitesettings.config)));
return settings;

public static SiteSettings FetchFromFile()
SiteSettings siteSettings;

XmlSerializer serializer = new XmlSerializer(typeof(SiteSettings));

using (StreamReader reader = new
= (SiteSettings)serializer.Deserialize(reader);

return siteSettings;



Here is our base page class, called BasePage, that essentially fetches the application settings and exposes the entire class via the protected field settings.  As all protected fields, settings is accessible to any class that derives from BasePage.


BasePage Class
public class BasePage : Page
protected SiteSettings settings;

public BasePage()
+=new EventHandler(LoadSettings);

private void LoadSettings(object sender, EventArgs e)
= SiteSettings.Fetch();


Last, we create a page that derives from BasePage, called WorkingPage, that essentially just displays the current application settings on a web page.  The settings are grabbed from the protected field settings in BasePage and displayed accordingly.


WorkingPage Class
public class WorkingPage : BasePage
protected Label SiteName;
protected Label SiteUrl;
protected Label SiteEmailAddress;

protected override void OnInit(EventArgs e)
base.OnInit (e);
this.Load +=new EventHandler(Page_Load);

private void Page_Load(object sender, EventArgs e)
if (!IsPostBack)

private void DisplaySettings()
= settings.Name;
= settings.Url;
= settings.EmailAddress;


And just to be complete, here is sitesettings.config and the sitesettings.aspx page used in the example:


<?xml version=1.0 encoding=utf-8?>
<SiteSettings xmlns:xsd=http://www.w3.org/2001/XMLSchema


<%@ Page Inherits=PageInheritance.WorkingPage AutoEventWireUp=false %>
<!DOCTYPE HTML PUBLIC -//W3C//DTD HTML 4.01 Transitional//EN
<meta httpequiv=Content-Type content=text/html; charset=iso-8859-1>
<title>SiteSettings Test</title>
<form runat=server>
<p>Site Name: <asp:Label id=SiteName runat=server /></p>
<p>Site Url: <asp:Label id=SiteUrl runat=server /></p>
<p>Site Email Address: <asp:Label id=SiteEmailAddress runat=server /></p>


Application settings aren’t the only things you can place in your base pages, but it’s a good place to start if base page classes are new to you.

This entry was posted in ASP.NET, C#. Bookmark the permalink. Follow any comments here with the RSS feed for this post.

5 Responses to ASP.NET Page Inheritance – Base Page Classes in your Web Applications

  1. David Hayden says:

    Good point, Sahil. It would be better to pull it over to a variable before doing the check and casting.

  2. David Hayden says:

    Thanks for pointing out the other posts, Raymond. Good stuff!

    You should post your slides or code on the demo as I love to read through code and learn best practices done by others.

  3. Sahil Malik says:

    There’s a problem in this logic.

    Check this out –

    if (HttpContext.Current.Cache["SiteSettings"] != null)

    return (SiteSettings)HttpContext.Current.Cache["SiteSettings"];

    So you read from the Cache. If you find it, you read AGAIN and return. What if between these 2 statements another thread kicked it out of the cache? You’re screwed.

    What u should do is, fetch out of cache, and assign to a variable. And then check for the variable’s being not null. If it is not null, return the variable.

    Man I love having time to read blogs :)

  4. Demo’d at my local .Net users group, for clarification :)

  5. I just did this exact demo, based on session wrapper classes, last Monday. Serializing session state information to disk for a session wrapper created as part of a base page class. Very similar to what I demo’d. Very good starting point for base page inheritance. For some more information, for those of you reading this post, check these links on how some of us others here at codebetter do some implementation into base pages:




Leave a Reply

Your email address will not be published. Required fields are marked *

You may use these HTML tags and attributes: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <s> <strike> <strong>