When is a Generic HttpHandler (an ashx, the IHttpHandler interface) reusable?

Question

I've been using Ashx along with jQuery . I've read msdn , I'm talking about the IHttpHandler.IsReusable Property.

Gets a value indicating whether another request can use the IHttpHandler instance.

What do they mean " the IHttpHandler instance. "? Are they trying to make it alike static for everyone to see and use ? Is it reusable by the same what ? ( QueryString, cookies, etc?)

If I write this:

public class MyHttpHandler : IHttpHandler
   {
      public void ProcessRequest(HttpContext context)
      {
         context.Response.Write(DateTime.Now.Ticks.ToString());      
      }

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

it appears each request will get its own up-to-date - Datetime value.

Answer 1

In your example, you're not managing any state. Anyone can call ProcessRequest as many times as they want on the same instance and they will get a new DateTime.

But what if you did this:

private DateTime _dateTime = DateTime.Now;

public void ProcessRequest(HttpContext context)
{
    context.Response.Write(_dateTime);
}

Now you'll get the same response every time after the handler instance is instantiated. Unless ASP.NET generates a new one every time.

IsReusable can indicate whether your handler class manages any state that is OK to share between separate requests. If it manages state that isn't OK to share, then it's not likely to be externally idempotent - or possibly even not thread-safe. Calling ProcessRequest with the same input conditions may not result in the same output, because your specific handler implementation also has some instance-level variables that are not OK to share when it determines the output. (And in fact, technically your current implementation is an example of that). In these cases the instance is probably not "reusable" - and ASP.NET needs to generate a new instance each time to ensure predictability.

So for cases where you don't manage state, or you have very simple handlers where the state is "obvious" (like the example we have here), IsResuable might seem pointless. But if you have a very complex handler - possibly one that does keep some state that's expensive to initialize but OK to share - you would want to indicate to ASP.NET it's OK to reuse it for performance.

Answer 2

Sorry to just post a link to the answer, but a great explanation of IsReusable:

IsReusable blog post

Essentially turn it on if your code is completely thread safe, leave it off if it's not. Well thats what I gather from it.

Answer 3

如果你有一个实例变量，我想你会发现它在很多调用中都是共享的，所以如果你的日期时间被设置为一个实例变量，你只需要在processrequest中返回它，我认为它将返回相同的值，而如果isreusable = false则不会，因为它会创建一个新的处理程序实例。

Answer 4

Apparently, this keeps the handler in memory and able to handle multiple requests. When set to false, it has to create a new instance of the handler for each incoming request.

public bool IsReusable
{
    get
    {
        return true;
    }
}