wrapping HttpHandler .NET

Question

I'm working on a project where most of the responses from my genericHandlers are the same.

We're using .NET and we request json data with jQuery calls to genericHandlers.

We have a return type that is used 90% of the time, it is a json similar to this: { response: { code: 0, return: myJson} }, and I treat that return in the JavaScript.

So whenever something goes wrong in the genericHandler I already have a class to treat errors and return them within that format.

What I'm looking for is ways to avoid using try catch in every single handler we create and repeat the code all over again.

Here is an example of how the "ProcessRequest" method would look like:

public void ProcessRequest(HttpContext context)
    {
        context.Response.ContentType = UContentType.Json;

        try
        {
            // My code here
        }
        catch (Exception ex)
        {
            UError.AddMessage(ex.Message);
            // Method that converts the errors into a json string 
            context.Response.Write(UMessage.SendErrorMessage());
        }            
    }

What I need is to wrap that method into something that would eliminate the repetition to that try catch in every handler.

I thought of using inheritance or something like that.

The end result I had in ming was to achieve something like this:

public class getUser : IHttpHandlerWithExceptionTreatment // a shorter name though ;)
{
    public void ProcessRequest(HttpContext context)
    {            
        // My code here                  
    }

    public bool IsReusable
    {
        get
        {
            return false;
        }
    }
}

And if anything threw an exception there it would be caught in that extended class or somewhere else.

I don't know whether I can use a design pattern (I thought about decorator or template) or just simple inheritance. I don't even know if that's a good idea. :)

But I'd like to know if that's possible.

Any ideas.

Hope I was clear about my doubt.

Thanks for your help

Answer 1

Probably the most straightforward way would be to create an abstract base class:

public abstract class HandlerBase : IHttpHandler
{
    bool IHttpHandler.IsReusable { get { return false; } }

    void IHttpHandler.ProcessRequest(HttpContext context)
    {
        try 
        {
            this.HandleRequest(context);
        }
        catch (Exception ex)
        {
            UError.AddMessage(ex.Message);
            context.Response.Write(UMessage.SendErrorMessage());
        }
    }

    protected abstract void HandleRequest(HttpContext context);
}

Then have your handlers inherit from HandlerBase instead of implement IHttpHandler directly:

public class FooHandler : HandlerBase
{
    protected override void HandleRequest(HttpContext context)
    {
        // Handle you some Foos here
    }
}