C# Customizable Embedded HTTPServer

Mark Swaanenburg

4.80/5 (10 votes)

Sep 12, 2007

CPOL

3 min read

108099

2774

A customizable embedded HTTPServer for C#.

Screenshot - screenshot2.jpg

Introduction

This article describes the usage of a small HTTP server library entirely written in C# that can be integrated and used in your own application. The purpose of this library is to provide developers with an easy to use and flexible way of generating HTTP responses on the fly based on the requested URI and/or the current state of the application.

Background

This library was developed by Hybrid GeoTools to act as an integrated web server to provide dynamic data to Google Earth. Although handling Google Earth's requests is a simple task at a first glance, it became apparent that not handling the HTTP protocol properly can cause unexpected results. For instance, not handling the Connect header properly caused Google Earth to reuse the connection while the server was actually waiting for a new connection. As a result, the request was not handled at all.

For this reason, the HybridDSP.Net library was developed. Currently, this library only contains the HTTPServer, but more services might be added in the future.

Design

The library exposes four classes and two interfaces:

HTTPServer - This class is the actual server. It manages the connections, the sessions, and the requests. It delegates the handling of a request to a request handler object that conforms to the IHTTPRequestHandler interface. This object is obtained through a request handler factory that's passed as one of the arguments of the contractor for HTTPServer. This factory has to conform to the IHTTPRequestHandlerFactory interface.
HTTPServerRequest - This class represents a request from a client to the server. The request handler factory can instantiate a request handler based on information obtained from the request. Once a request handler has been instantiated, it will be used to handle the request. If the request contains any data, a Stream can be obtained from the request to get the data (and do whatever needs to be done with it).
HTTPServerResponse - This class represents the response from the server to the client. It's initialized to return HTTP OK, by default. Once all headers are set correctly, a Stream can be obtained by sending the header to the client. The body of the response can be written to this Stream.

IHTTPRequestHandler - This interface defines the contract to which any request handler needs to conform. There's only one method defined:

public interface IHTTPRequestHandler
{
    void HandleRequest(HTTPServerRequest request, HTTPServerResponse response);
}

IHTTPRequestHandlerFactory - This interface defines the contract to which any request handler factory needs to conform. Again, there's only one method defined:

public interface IHTTPRequestHandlerFactory
{
    IHTTPRequestHandler CreateRequestHandler(HTTPServerRequest request);
}

Using the code

First of all, at least one request handler needs to be defined in order to be able to do anything.

class DateTimeHandler : IHTTPRequestHandler
{
    public void HandleRequest(HTTPServerRequest request, HTTPServerResponse response)
    {
        if (request.URI == "/")
        {
            /**
             * In this example we'll write the body into the
             * stream obtained by response.Send(). This will cause the
             * KeepAlive to be false since the size of the body is not
             * known when the response header is sent.
             **/
            response.ContentType = "text/html";
            using (Stream ostr = response.Send())
            using (TextWriter tw = new StreamWriter(ostr))
            {
                tw.WriteLine("<html>");
                tw.WriteLine("<head>");
                tw.WriteLine("<title>Date Time Server</title>");
                tw.WriteLine("<meta http-equiv=\"refresh\" content=\"2\">");
                tw.WriteLine("</header>");
                tw.WriteLine("<body>");
                tw.WriteLine(DateTime.Now.ToString());
                tw.WriteLine("</body>");
                tw.WriteLine("</html>");
            }
        }
        else
        {
            response.StatusAndReason = HTTPServerResponse.HTTPStatus.HTTP_NOT_FOUND;
            response.Send();
        }
    }
}

This handler will generate an HTML page that shows the current date and time and refreshes itself every two seconds. If the request is not for the root, it will return an HTTP NOT FOUND response.

Next, a request handler factory needs to be defined in order to use the just created request handler.

class RequestHandlerFactory : IHTTPRequestHandlerFactory
{
    public IHTTPRequestHandler CreateRequestHandler(HTTPServerRequest request)
    {
        return new DateTimeHandler();
    }
}

This factory will simply always instantiate a DateTimeHandler.

The last step is to hook the whole thing together. To do this one has to instantiate a factory and pass it to the contructor of the HTTPServer object. Then the server can simply be started.

static void Main(string[] args)
{
    RequestHandlerFactory factory = new RequestHandlerFactory();
    HTTPServer server = new HTTPServer(factory, 8080);
    server.Start();

    Console.Write("Press enter to abort.");
    Console.ReadKey();

    server.Stop();
}

Now, take your favorite web browser, browse to http://localhost:8080, and enjoy your very own integrated web server.

History

12 September 2007 - Initial issue.
13 September 2007 - Updated the screenshot.
14 November 2007 - Added support for IPv6.
15 November 2007 - Fixed issue in killing the server thread.