Writing a raw web service using an HttpHandler

The ASP.NET web service infrastructure provides a RPC style abstraction for web serivces. You write a web method that looks like any other C# function and simply add a [WebMethod] attribute. ASP.NET then reflects on the name of the method, your input parameters and return types and creates a web service end point for you. If you use the 'Add Web Reference' facility for the client, you never have to consider what the web service will look like in terms of WSDL or XML, it just looks like a remote procedure call. This is fine in many scenarios, but sometimes what you are interested in is the actual XML message itself and you don't need it deserialized as .net types. It's pretty straightforward to write a web service using an HttpHandler to grab the raw SOAP envelope. The IHttpHandler interface is the core endpoint interface for anything that handles a web request in .net. All you need to do is write a class that implements the interface and then register it in Web.config:

<httpHandlers>
<add verb="*" path="MyServiceEndpoint.asmx" type="MyService.MyHandler, MyHandler" />
</httpHandlers>

IHttpHandler provides a method 'PrcessRequest' that looks like this:

void ProcessRequest(HttpContext context);

You take the HttpContext.Request.InputStream and read the raw SOAP envelope from it. When you're ready to return the response, simply write your SOAP envelope response to the HttpContext.Response.OutputStream. A couple of other things to consider are providing a default information page and your web service's WSDL file. In ASP.NET if you execute an HTTP GET request against your web service, ASP.NET builds a nice web page naming your service and listing the operations. If you append WSDL to the querystring, it builds and returns the WSDL for the web service. You can replicate this behaviour by looking for a GET request (web service requests are typically POST) and then streaming either a descriptive web page or a WSDL document to the response. Here are functions that look for a GET request and stream either the WSDL file or the default page file into the response.

public void ProcessRequest(HttpContext context)
{
switch(context.Request.HttpMethod)
{
 case "GET":
  ProcessGetRequest(context);
  break;
 case "POST":
  ProcessPostRequest(context);
  break;
 default:
  throw new ApplicationException(
   string.Format("HTTP Method '{0}' is not supported.", context.Request.HttpMethod));
}
}

void ProcessGetRequest(HttpContext context)
{
// is this a request for the WSDL file?
string filePath;
if(context.Request.QueryString.ToString().ToUpper() == "WSDL")
{
 filePath = context.Server.MapPath(myWsdlPath);
}
else
{
 filePath = context.Server.MapPath(myDefaultPagePath);
}
RespondWithFile(context, filePath);
}

void RespondWithFile(HttpContext context, string filePath)
{
using(FileStream fileStream = new FileStream(filePath, FileMode.Open, FileAccess.Read))
{
 byte[] buffer = new byte[streamBufferSize];
 int bytes;
 while((bytes = fileStream.Read(buffer, 0, streamBufferSize)) > 0)
 {
  context.Response.OutputStream.Write(buffer, 0, bytes);
 }
 context.Response.OutputStream.Flush();
}
}

This technique can be usefull when you're writing stuff to route or map web services. Currently I'm working on a mapping service that takes a request and forwards it on to another web service with a different schema. Using the handler I can simply grab the SOAP envelope and run it through an XSLT to transform it to target schema and then run the response through another XSLT to transform it back to the originating web service's response schema.