Creating the Project

I am going to create a second project called CommonModules within the Visual Studio solution that contains the SimpleApp project. This is not a requirement of using the PreApplicationStartMethod attribute, but it makes it easier for me to demonstrate the technique and use the output from the CommonModules project as a dependency of the SimpleApp project.

Right-click the Solution item in the Visual Studio Solution Explorer and select Add New Project from the pop-up menu. Visual Studio will display the Add New Project dialog window; select the Installed Visual C# Class Library project type, set the name to CommonModules, and click the OK button to create the project.

I need to add the System.Web assembly to the CommonModules project so that I have access to the IHttpModule interface and the context objects. Click the CommonModules project in the Solution Explorer and select Add Reference from the Visual Studio Project menu. Locate the System.Web assembly (you’ll find it in the Assemblies Framework section) and check the box next it, as shown in Figure 4-3. Click the OK button to dismiss the dialog box and add the assembly reference to the project.

I need to add a reference from the SimpleApp project to the CommonModules project so that the module I create will be available in the web application. Select the SimpleApp project in the Solution Explorer and select Add Reference from the Project menu. Click the Solution section and check the box next to the CommonModules entry, as shown in Figure 4-4. Click the OK button to dismiss the dialog box and add the assembly reference to the project.

Now that there are two projects in the solution, I need to tell Visual Studio which one I want to start when I run the debugger. Right-click the SimpleApp project in the Solution Explorer and select Set As StartUp Project from the pop-up menu.

Creating the Module

Visual Studio adds a class file called Class1.cs to the new project. Rename this file to InfoModule.cs and edit the contents to match Listing 4-4.

Listing 4-4.  The Contents of the InfoModule.cs File

using System.Web;
 
namespace CommonModules {
 
    public class InfoModule : IHttpModule {
         
        public void Init(HttpApplication app) {
            app.EndRequest += (src, args) => {
                HttpContext ctx = HttpContext.Current;
                ctx.Response.Write(string.Format(
                    "<div class='alert alert-success'>URL: {0} Status: {1}</div>",
                    ctx.Request.RawUrl, ctx.Response.StatusCode));
            };
        }
 
        public void Dispose() {
            // do nothing - no resources to release
        }
    }
}

This module handles the EndRequest event and appends a fragment of HTML to the response, which details the URL that was requested and the status code sent to the browser. I have handled the event using a lambda expression (just for variety), but the overall structure/nature of the module is similar to the TimerModule module I created in the previous section.

Creating the Registration Class

To automatically register a module, I need to create a method that calls the static HttpApplication.RegisterModule method and then apply the PreApplicationStartMethod attribute to call this method when the application starts. I like to define a separate class to register the module because it means I can register all of the modules in the project in a single place. I added a class file called ModuleRegistration.cs to the CommonModules project. Listing 4-5 shows the contents of the new file.

Listing 4-5.  The Contents of the ModuleRegistration.cs File

using System.Web;
 
[assembly: PreApplicationStartMethod(typeof(CommonModules.ModuleRegistration),
    "RegisterModule")]
 
namespace CommonModules {
    public class ModuleRegistration {
 
        public static void RegisterModule() {
            HttpApplication.RegisterModule(typeof(CommonModules.InfoModule));
        }
    }
}

The arguments for the PreApplicationStartMethod are the type of the class that contains the method that will be executed when the application starts and the name of that method, expressed as a string. I have applied the attribute in the file that contains the class and the method, as follows:

...
[assembly: PreApplicationStartMethod(typeof(CommonModules.ModuleRegistration),
    "RegisterModule")]
...

The method must be public and static and cannot take any arguments. You are free to put any statements in the method, but it is good practice to only perform tasks that configure the code in the project to work with the web application, such as registering modules.

Testing the Module

You can test the effect of the PreApplicationStartMethod attribute by selecting Start Debugging from the Visual Studio Debug menu. Visual Studio will build both projects, start the application, and load the module from the CommonModules project. You can see the message that the module adds to the response in Figure 4-5.

Figure 4-5. The output from the InfoModule

Using Module Events

My timer module is a nice demonstration of the way that modules can participate in the request processing life cycle and—optionally—manipulate the response sent to the client, but it has one problem: The timing information that it generates is locked away, which will force me to duplicate functionality if I need to do something similar in another module. Not only does this create a code maintenance concern—an anathema in MVC applications—but it also adds to the amount of time taken to process each request, leading to inconsistencies in the timing information within different modules.

What I need is the ability to share the timing information with other modules so that I can build on my core functionality, which I can do by creating a module event. Module events allow modules to coordinate their activities and share data. Table 4-5 puts module events in context.

using System;
using System.Diagnostics;
using System.Web;
 
namespace SimpleApp.Infrastructure {
 
    public class RequestTimerEventArgs : EventArgs {
        public float Duration { get; set; }
    }
 
    public class TimerModule : IHttpModule {
        public event EventHandler<RequestTimerEventArgs> RequestTimed;
        private Stopwatch timer;
 
        public void Init(HttpApplication app) {
            app.BeginRequest += HandleEvent;
            app.EndRequest += HandleEvent;
        }
 
        private void HandleEvent(object src, EventArgs args) {
            HttpContext ctx = HttpContext.Current;
            if (ctx.CurrentNotification == RequestNotification.BeginRequest) {
                timer = Stopwatch.StartNew();
            } else {
                float duration = ((float) timer.ElapsedTicks) / Stopwatch.Frequency;
                ctx.Response.Write(string.Format(
                    "<div class='alert alert-success'>Elapsed: {0:F5} seconds</div>",
                    duration));
                if (RequestTimed != null) {
                    RequestTimed(this,
                        new RequestTimerEventArgs { Duration = duration });
                }
            }
        }
 
        public void Dispose() {
            // do nothing - no resources to release
        }
    }
}

using System.IO;
using System.Web;
using System.Web.UI;
 
namespace SimpleApp.Infrastructure {
    public class TotalTimeModule : IHttpModule {
        private static float totalTime = 0;
        private static int requestCount = 0;
 
        public void Init(HttpApplication app) {
            IHttpModule module = app.Modules["Timer"];
            if (module != null && module is TimerModule) {
                TimerModule timerModule = (TimerModule)module;
                timerModule.RequestTimed += (src, args) => {
                    totalTime += args.Duration;
                    requestCount++;
                };
            }
 
            app.EndRequest += (src, args) => {
                app.Context.Response.Write(CreateSummary());
            };
        }
 
        private string CreateSummary() {
            StringWriter stringWriter = new StringWriter();
            HtmlTextWriter htmlWriter = new HtmlTextWriter(stringWriter);
            htmlWriter.AddAttribute(HtmlTextWriterAttribute.Class,
                "table table-bordered");
            htmlWriter.RenderBeginTag(HtmlTextWriterTag.Table);
                htmlWriter.AddAttribute(HtmlTextWriterAttribute.Class, "success");
                htmlWriter.RenderBeginTag(HtmlTextWriterTag.Tr);
                    htmlWriter.RenderBeginTag(HtmlTextWriterTag.Td);
                        htmlWriter.Write("Requests");
                        htmlWriter.RenderEndTag();
                        htmlWriter.RenderBeginTag(HtmlTextWriterTag.Td);
                        htmlWriter.Write(requestCount);
                    htmlWriter.RenderEndTag();
                htmlWriter.RenderEndTag();
                    htmlWriter.AddAttribute(HtmlTextWriterAttribute.Class, "success");
                    htmlWriter.RenderBeginTag(HtmlTextWriterTag.Tr);
                        htmlWriter.RenderBeginTag(HtmlTextWriterTag.Td);
                        htmlWriter.Write("Total Time");
                        htmlWriter.RenderEndTag();
                        htmlWriter.RenderBeginTag(HtmlTextWriterTag.Td);
                        htmlWriter.Write("{0:F5} seconds", totalTime);
                    htmlWriter.RenderEndTag();
                htmlWriter.RenderEndTag();
            htmlWriter.RenderEndTag();
            return stringWriter.ToString();
        }
 
        public void Dispose() {
            // do nothing
        }
    }
}

...
IHttpModule module = app.Modules["Timer"];
if (module != null && module is TimerModule) {
    TimerModule timerModule = (TimerModule)module;
    timerModule.RequestTimed += (src, args) => {
        totalTime += args.Duration;
        requestCount++;
    };
}
...

<?xml version="1.0" encoding="utf-8"?>
<configuration>
  <appSettings>
    <add key="webpages:Version" value="3.0.0.0" />
    <add key="webpages:Enabled" value="false" />
     <add key="ClientValidationEnabled" value="true" />
    <add key="UnobtrusiveJavaScriptEnabled" value="true" />
  </appSettings>
  <system.web>
    <compilation debug="true" targetFramework="4.5.1" />
    <httpRuntime targetFramework="4.5.1" />
  </system.web>
  <system.webServer>
    <modules>
      <add name="Timer" type="SimpleApp.Infrastructure.TimerModule"/>
      <add name="Total" type="SimpleApp.Infrastructure.TotalTimeModule"/>
    </modules>
  </system.webServer>
</configuration>

...
string.Format("<div class='alert alert-success'>Elapsed: {0:F5} seconds</div>",
    duration));
...

Understanding the Built-in Modules

The ASP.NET framework contains a number of built-in modules, many of which support the core platform services that I describe in Part 3 of this book. Some of these modules define events that you can handle to get fine-grained information about their activities, although for the most part, you interact with the functionality they provide through the context objects that I described in Chapter 3. In this section, I am going to show you how to enumerate the modules, explain what each of them does, and describe the events that some of them define. To generate the list of modules, I have added a new action method to the Home controller, as shown in Listing 4-9.

Listing 4-9.  Adding an Action Method to the HomeController.cs File

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web.Mvc;
using SimpleApp.Models;
 
namespace SimpleApp.Controllers {
    public class HomeController : Controller {
 
        public ActionResult Index() {
            return View(GetTimeStamps());
        }
 
        [HttpPost]
        public ActionResult Index(Color color) {
            Color? oldColor = Session["color"] as Color?;
            if (oldColor != null) {
                Votes.ChangeVote(color, (Color)oldColor);
            } else {
                Votes.RecordVote(color);
            }
            ViewBag.SelectedColor = Session["color"] = color;
            return View(GetTimeStamps());
        }
 
        public ActionResult Modules() {
            var modules = HttpContext.ApplicationInstance.Modules;
            Tuple<string, string>[] data =
                modules.AllKeys
                    .Select(x => new Tuple<string, string>(
                        x.StartsWith("__Dynamic") ? x.Split('_',',')[3] : x,
                        modules[x].GetType().Name))
                    .OrderBy(x => x.Item1)
                    .ToArray();
            return View(data);
        }
 
        private List<string> GetTimeStamps() {
            return new List<string> {
                string.Format("App timestamp: {0}",
                    HttpContext.Application["app_timestamp"]),
                string.Format("Request timestamp: {0}", Session["request_timestamp"]),
            };
        }
    }
}

The new action method is called Modules, and it uses LINQto generate an array of Tuple<string, string> objects from the module objects returned by the HttpApplication.Module property. Modules registered using the PreApplicationStartMethod URL are done so using the fully qualified class name prefixed with __Dynamic_, and the LINQ methods locate and reformat the names to make them more readable. The result is an array of tuples that are sorted by name that I pass to the View method, which tells the MVC framework to render the view default associated with the action method.

To create this view, right-click the Modules action method in the code editor and select Add View from the pop-up menu. Ensure View Name is set to Modules, select Empty (without model) for Template, and uncheck the option boxes. Click Add to create the Views/Home/Modules.cshtml file and add the markup shown in Listing 4-10.

Listing 4-10.  The Contents of the Modules.cshtml File

@model Tuple<string, string>[]
@{
    Layout = null;
}
 
<!DOCTYPE html>
 
<html>
<head>
    <meta name="viewport" content="width=device-width" />
    <title>Modules</title>
    <link href="∼/Content/bootstrap.min.css" rel="stylesheet" />
    <link href="∼/Content/bootstrap-theme.min.css" rel="stylesheet" />
</head>
<body class="container">
    <table class="table table-bordered table-striped">
        <thead>
            <tr><th>Name</th><th>Type</th></tr>
        </thead>
        <tbody>
            @foreach (Tuple<string, string> x in Model) {
                <tr><td>@x.Item1</td><td>@x.Item2</td></tr>
            }
        </tbody>
    </table>
</body>
</html>

The view consists of a table element that I have styled using Bootstrap and that contains a row for each of the Tuple objects passed from the controller. You can see the list of built-in modules by starting the application and requesting the /Home/Modules URL, as illustrated by Figure 4-7.

It can be hard to read the details of the modules from the figure, so I have repeated the information in Table 4-7 and described each module.

Some of the built-in modules define events that can be handled to receive notifications when important changes occur. I have listed these modules and their events in Table 4-8.

The most widely used events are those defined by the Session module because they allow applications to associate default state data with sessions when they are created. I explain how ASP.NET sessions and state data work in Chapter 10.

Summary

In this chapter, I described the role that modules play in ASP.NET request handling. I showed you how to create modules by implementing the IHttpModule interface and how to register those modules with ASP.NET, both through the Web.config file and by using the PreApplicationStartMethod assembly attribute. I showed you how modules can provide services by defining events and demonstrated the process for locating another module and creating an event handler. I completed the chapter by describing the built-in modules, many of which provide services that I describe in Part 3 of this book. In the next chapter, I describe the handler component, which is responsible for generating responses for HTTP requests.