Use the Asynchronous Power of ASP.NET to Create a Simple, Reusable Page for Displaying a Processing Message

• Download demo project - 15.9 Kb

Introduction

Sometimes we may find it necessary for our users to run long processes when using the web as a user interface. Since patience is not a typical trait of web users, we run into the issue of needing to entertain them, prevent multiple clicks, or keep them from pulling their hair out while we're running time-consuming processes in the background. There are several tactics for doing this on the web, but I have found none of these to be as simple as employing .NET's asynchronous threading. I hope that you find this helpful.

Using the code

The relevant portion of the sample application included with this article consists of two C# Web Forms i.e., SubmitLongProcess.aspx, ProcessingMessage.aspx. SubmitLongProcess.aspx is used for starting the process and redirecting the user to ProcessingMessage.aspx. ProcessingMessage.aspx is the processing message page that is used to display a friendly message to the user while the long process is running in the background. Once the long process completes, ProcessingMessage.aspx redirects the user to a specified page.

SubmitLongProcess.aspx

As you can see in the code below, .NET makes firing off a new thread quite simple. Without fully qualifying the code, you'll need to include a using directive to the System.Web.Threading namespace.

using System.Web.Threading

You can see that all I'm doing in the SubmitButton_Click event is initializing the session variable, initializing and starting the new thread, then redirecting the user to the ProcessingMessage.aspx page. Notice that I've included two querystring name/value pairs in the URL parameter of the Response.Redirect method. One is used to specify the redirect page after processing is complete and the other is used to inform ProcessingMessage.aspx what session variable to check.

Response.Redirect("ProcessingMessage.aspx?redirectPage" + 
      "=SubmitLongProcess.aspx&ProcessSessionName=" + PROCESS_NAME);

The StartLongProcess() method runs in the background on a new thread while the user is redirected to the ProcessingMessage.aspx page. This method consists of two important lines of code. The first is used to mimic a long process by forcing the thread to sleep for a specified amount of time. Once the thread is done sleeping, the second line of code is used to set the session variable equal to true. Setting this variable equal to true informs the ProcessingMessage.aspx that the long process is complete.

using System;
using System.Collections;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Web;
using System.Web.SessionState;
using System.Web.UI;
using System.Threading;
using System.Web.UI.WebControls;
using System.Web.UI.HtmlControls;

namespace AsynchronousProcessing
{
    public class ProcessingMessage : System.Web.UI.Page
    {
        protected System.Web.UI.WebControls.TextBox txtProcessLength;
        protected System.Web.UI.WebControls.Button SubmitButton;
        private const string PROCESS_NAME = "Process";

        private void Page_Load(object sender, System.EventArgs e)
        {

        }

        private void SubmitButton_Click(object sender, System.EventArgs e)
        {
            //Initialize Session Variable
            Session[PROCESS_NAME] = false;

            //Create and initialize new thread with the 
            //address of the StartLongProcess function
            Thread thread = new Thread(new ThreadStart(StartLongProcess));

            //Start thread
            thread.Start();

            //Pass redirect page and session var name 
            //to the process wait (interum) page
            Response.Redirect("ProcessingMessage.aspx?" + 
              "redirectPage=SubmitLongProcess.aspx&ProcessSessionName=" 
              + PROCESS_NAME);
        }

        private void StartLongProcess()
        {
            //Replace the following line of code with your long process
            Thread.Sleep(Convert.ToInt32(this.txtProcessLength.Text)* 1000);

            //Set session variable equal to true when process completes
            Session[PROCESS_NAME] = true;
        }
    }
}

ProcessingMessage.aspx

The ProcessingMessage.aspx page is used to inform the user how long he/she has waited and redirects the user to the specified page when the long process is complete. With the source code, I've included a simple yet effective animated gif called Processing.gif that's used to simulate a process occurring in the background. I've also forced the page to refresh every second by adding the equiv-refresh meta tag to the aspx portion of the Web form.

<meta http-equiv="refresh" content="1">

In the Page_Load method, I am setting a session variable called Session["ProcessTime"]. This variable is used to keep track of how long the process has been running and display this to the user. Every time the page refreshes, Session["ProcessTime"] is incremented by 1.

Session["ProcessTime"] = Convert.ToInt32(Session["ProcessTime"]) + 1;

You'll also notice that I'm checking the state of the session variable that's waiting to be set on the triggering page. Once this variable equals true, I set both the Session[processSessionName] and Session["ProcessTime"] equal to null and redirect the user to the page specified in the querystring. I set the session variables equal to null in case the user performs another long process within the same session.

using System;
using System.Collections;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Web;
using System.Web.SessionState;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.HtmlControls;

namespace AsynchronousProcessing
{
    public class WebForm1 : System.Web.UI.Page
    {
        protected System.Web.UI.WebControls.Label StatusMessage;
    
        private void Page_Load(object sender, System.EventArgs e)
        {
            string redirectPage = Request.QueryString["redirectPage"];
            string processSessionName = Request.QueryString["ProcessSessionName"];
            if (Session["ProcessTime"] == null)
            {
                StatusMessage.Text = "Process has been running for 0 seconds";
                Session["ProcessTime"] = 0;
            }
            else
            {
                Session["ProcessTime"] = Convert.ToInt32(Session["ProcessTime"]) + 1;
                StatusMessage.Text = "Process has been running for " + 
                        Session["ProcessTime"].ToString() + " seconds";
            }

            if ((bool)Session[processSessionName] == true)
            {
                Session[processSessionName] = null;
                Session["ProcessTime"] = null;
                Response.Redirect(redirectPage);
            }
        }
    }
}