Simple MessageBox functionality in ASP.NET

• Download demo project - 17 Kb

Introduction

When moving from Windows Forms to ASP.NET Web Forms, an API that may be missed is that offered by the System.Windows.Forms.MessageBox Class. Sometimes when developing web forms the application may wish to inform the user of a successful or, god forbid, an unsuccessful operation. An effective way to communicate an important message to the user is through the use a MessageBox or, with respect to web programming, a JavaScript "alert".

The MessageBox class in the System.Windows.Forms namespace is usable only from Windows Forms and NOT ASP.NET Web Forms. In order to alert the user we need to inject some client side code into the HTML page. This is a simple task but can become quite a nuisance if this functionality is required on a regular basis.

I thought that it would be nice if we could simply call a static method from any page that would deal with the client side JavaScript required to display the alert's. I decided to write a small MessageBox class with a static Show(); method.

Using the code

To use this code in your projects, simply call the static Show() method of the MessageBox class and pass in the string that you wish to display to the user.

For example:

private void Page_Load( object sender, System.EventArgs e )
{
  MessageBox.Show( "Hello World!" );
  MessageBox.Show( "This is my second message." );
  MessageBox.Show( "Alerts couldnt be simpler." );
}

Behind the scenes

The first time the Show method is invoked from a Page, a System.Collections.Queue is created and stored in a private static HashTable. The Queue is used to hold all of the message's associated with current executing Page. We also "wire up" the Page.UnLoad event so we can write the client side JavaScript to the response stream after the Page has finished rendering its HTML.

The reason we store the Queue in a Hashtable is because we are using static methods. There is the potential for multiple pages to be using the class at the same time (on separate threads). Therefore we need to make sure we know which messages belong to which page. To accomplish this we simply use the Page's reference as the key in the HashTable. We obtain a reference to the current executing page by casting the current IHttpHandler to System.Web.UI.Page. The current IHttpHandler can be obtained from HttpContext.Current.Handler. In most cases this will be a class either directly or indirectly derived from System.Web.UI.Page.

Source Code

public class MessageBox
{
  private static Hashtable m_executingPages = new Hashtable();

  private MessageBox(){}

  public static void Show( string sMessage )
  {
    // If this is the first time a page has called this method then
    if( !m_executingPages.Contains( HttpContext.Current.Handler ) )
    {
      // Attempt to cast HttpHandler as a Page.
      Page executingPage = HttpContext.Current.Handler as Page;

      if( executingPage != null )
      {
        // Create a Queue to hold one or more messages.
        Queue messageQueue = new Queue();

        // Add our message to the Queue
        messageQueue.Enqueue( sMessage );

        // Add our message queue to the hash table. Use our page reference
        // (IHttpHandler) as the key.
        m_executingPages.Add( HttpContext.Current.Handler, messageQueue );

        // Wire up Unload event so that we can inject 
        // some JavaScript for the alerts.
        executingPage.Unload += new EventHandler( ExecutingPage_Unload );
      }   
    }
    else
    {
      // If were here then the method has allready been 
      // called from the executing Page.
      // We have allready created a message queue and stored a
      // reference to it in our hastable. 
      Queue queue = (Queue) m_executingPages[ HttpContext.Current.Handler ];

      // Add our message to the Queue
      queue.Enqueue( sMessage );
    }
  }


  // Our page has finished rendering so lets output the
  // JavaScript to produce the alert's
  private static void ExecutingPage_Unload(object sender, EventArgs e)
  {
    // Get our message queue from the hashtable
    Queue queue = (Queue) m_executingPages[ HttpContext.Current.Handler ];

    if( queue != null )
    {
      StringBuilder sb = new StringBuilder();

      // How many messages have been registered?
      int iMsgCount = queue.Count;

      // Use StringBuilder to build up our client slide JavaScript.
      sb.Append( "<script language="'javascript'">" );

      // Loop round registered messages
      string sMsg;
      while( iMsgCount-- > 0 )
      {
        sMsg = (string) queue.Dequeue();
        sMsg = sMsg.Replace( "\n", "\\n" );
        sMsg = sMsg.Replace( "\"", "'" );
        sb.Append( @"alert( """ + sMsg + @""" );" );
      }

      // Close our JS
      sb.Append( @"</script>" );

      // Were done, so remove our page reference from the hashtable
      m_executingPages.Remove( HttpContext.Current.Handler );

      // Write the JavaScript to the end of the response stream.
      HttpContext.Current.Response.Write( sb.ToString() );
    }
  }
}

This article has no explicit license attached to it but may contain usage terms in the article text or the download files themselves. If in doubt please contact the author via the discussion board below.

A list of licenses authors might use can be found here