Implementing interfaces is quite easy. If you are completely new to interfaces and do not understand them at all. I recommend you take a look at an article I wrote which describes the basics of how to use interfaces.

The IHttpHandler interface is a small one, containing only two methods. One is a property which is likely to have a set value. The other is the method which process the request. It is aptly named ProcessRequest. It takes as a parameter an HttpContext variable which is basically a one-stop shop object for dealing with requests. It gives you access to necessary objects and information.

The IReusable property does exactly as its name states. It determines for this class whether an instance of the class can be reused. If this value is set to true then the same class will continue to be used for subsequent requests. This means you could keep a count inside the class of the number of requests. You could have class-level variables handling the requests. This also means that the state of the class will change from request to request, which can cause problems if not handled correctly. The easiest answer is just to say that a class is not reusable unless you actually need it to be.

The last and most important function involved in HttpHandlers is the ProcessRequest method. As I stated earlier, it has one parameter of type HttpContext. This parameter gives access to the Response and Request objects which are two of the most commonly used objects in ASP.NET, and as such should be reasonably well understood. Request gives all of the information about the request which has been made, and Response is all of the information about the response which will be sent back to the browser. The context will also give access to the Sever and Application objects and plenty more.

In this example I explain how all of this works and just use a simple example to illustrate what I mean. I leave creating a more advanced solution up to future articles I write, as well as an exercise for the reader. I will name the handler SimpleHandler and set it to implement IHttpHandler. This is what the class looks like at the beginning.

Listing 1: SimpleHandler Empty

namespace RollYourOwnHttpHandler
{
    public class SimpleHandler : IHttpHandler
    {
        public SimpleHandler()
        {
        }
    }
}

Right now we have a compiler error, so we need to implement the interface we are saying we will implement. If we right click on the interface name and choose the "Implement Interface" option, it will add this code for us.

Listing 2: Interface Implementation

#region IHttpHandler Members
 
public bool IsReusable
{
    get { throw new NotImplementedException(); }
}
 
public void ProcessRequest(HttpContext context)
{
    throw new NotImplementedException();
}
 
#endregion

This code is just enough to get our class compiling. It will not work yet. First we need to remove those NotImplementedExceptions it is throwing. We can start with the IReusable property since it is by far the easier of the two.

In our example we will not be storing any class level information, so the state of our handler instance will never change. This means we should be relatively safe using the same instance of this class to handle multiple requests. This will make things nice for our solution as long as we maintain this lack of state. So for now we can just set the IsReusable property to true. Just so it is clear, I am changing that property to the following code.

Listing 3: IsReusable Property

public bool IsReusable
{
  get { return true; }
}

This leaves us with only one section of code left to write: the ProcessRequest method. In this section you can make your code as simple or as complicated as you like. Perhaps you will just be keeping a count of something. Maybe you will be making a record in a database which is logging this transaction. Or you could be doing some complex calculations about something. Either way this is the core of the handler. This is the handling code. Do in here whatever you wish. Keep in mind that if you are doing anything which affects the state of this instance of this class you will want to pay careful attention to that state as well as the IsReusable property.

Since this is just an example showing how to perform this action, it will just be a simple hello world program. To do this we can use the context object to give us access to the Response object. We can then just write some html directly into the Response. This is certainly not how you would want to use any complicated handlers, but it works well enough for our example.

Listing 4: ProcessRequest Method

public void ProcessRequest(HttpContext context)
{
    context.Response.Write("<html><head><title>Hi there!</title></head>" + 
        "<body>Hello world!</body></html>");
}

Notice that there are plenty of uses for HttpHandler. You could do many different tasks with them. This simple method is just to illustrate how to implement this method. You can certainly write plenty of other code here.