Connect Your Site With HttpContext Items
(
May 06 2007 - 03:36:44 PM by
Timothy Khouri) - [
print article]
ASP.NET gives developers a lot of powerful tools to seperate functionality into Master Pages, Custom Controls, User Controls and Content Pages allowing clean and segragated application design. The problem comes in when you actually WANT two pages to talk to each other. A common scenario is when you have a control, such as a DropDownList, on one part of the page that needs to filter results on another part of the page that is not directly accessable (meaning it's in a UserControl, or part of the MasterPage and you are in another UserControl or the ContentPage). This article will describe how to easily tie your entire web application together without running into cross-threading issues due to using static objects.
The Problem With Static
First we want to discuss why you can't just use a bunch of static objects to 'cheat' the system. Because web applications are multi-threaded, meaning every person that hits your site is running his own "instance" of your web site, you can really step on your toes if you use static objects to set a value, then retrieve it later in the page cycle. This is because another user may hit your site in the meantime and changed that value to something else when you didn't expect it! Even if you test your site a thousand times, you'll never see this issue until you launch your web application, because you are just one person hitting your site.
public static class SiteObjects
{
private static string selectedArticle;
public static string SelectedArticle
{
get { return selectedArticle; }
set { selectedArticle = value; }
}
}
Static Accessors To Instance Objects
So the answer to our problems is to tie into the HttpContext.Items that is associated with current request. The HttpContext.Items is a collection of properties that you can set anything inside of, and it will be accessable in any page or control of your web application. It is thread safe because every thread gets it's own 'bucket' to put things in!
public static class SiteObjects
{
public static string SelectedArticle
{
get { return HttpContext.Current.Items["selectedArticle"] as string; }
set { HttpContext.Current.Items["selectedArticle"] = value; }
}
}
You can extend this very simple "SiteObjects" file to include things like your own custom events that you can tap into. Let's use that example above about needing to filter results from one UserControl to another. Here we are going to setup our own custom event so that we communicate from one control to another.
public static class SiteObjects
{
private static EventHandlerList CategoryChangedEvents
{
get
{
if (HttpContext.Current.Items.Contains("categoryChanged") == false)
{
HttpContext.Current.Items["categoryChanged"] = new EventHandlerList();
}
return (EventHandlerList)HttpContext.Current.Items["categoryChanged"];
}
}
public static event EventHandler CategoryChanged
{
add
{
SiteObjects.CategoryChangedEvents.AddHandler(HttpContext.Current, value);
}
remove
{
SiteObjects.CategoryChangedEvents.RemoveHandler(HttpContext.Current, value);
}
}
public static void RaiseCategoryChangedEvent(object sender, EventArgs e)
{
EventHandler handler = (EventHandler)SiteObjects.CategoryChangedEvents["categoryChanged"];
if (handler != null)
{
handler(sender, e);
}
}
}
So in conclusion, if you need to tie your web application together, but you're not quite ready to create a "three-tier" enterprise level application, you can use this simple approach. If you are using ASP.NET 2.0, then you'll put this code inside your App_Code folder under it's own code file. With this example above you can tap into your needed information all over your site; in your UserControls, MasterPages, ContentPages and anywhere else you may need to.