Async EventHandlers in a HttpModule

Question

How do you set them up?

If I have the following code in a HttpModule.

public static event EventHandler<PostProcessingEventArgs> OnPostProcessing;

And in an async PostAuthorizeRequest task set up using EventHandlerTaskAsyncHelper.

// Fire the post processing event.
EventHandler<PostProcessingEventArgs> handler = OnPostProcessing;
if (handler != null)
{
    handler(this, new PostProcessingEventArgs { CachedPath = cachedPath });
}

And then tap into it using this.

ProcessingModule.OnPostProcessing += this.WritePath;    

private async void WritePath(object sender, PostProcessingEventArgs e)
{
    await Task.Factory.StartNew(() => Debug.WriteLine(e.CachedPath));
}

I get the following error.

An asynchronous module or handler completed while an asynchronous operation was still pending.

Edit

Ok so before I saw all these answers I got it to not throw the error by raising the event handler as follows.

EventHandlerTaskAsyncHelper postProcessHelper = 
new EventHandlerTaskAsyncHelper(this.PostProcessImage);

context.AddOnPostRequestHandlerExecuteAsync(postProcessHelper.BeginEventHandler,
postProcessHelper.EndEventHandler);

private Task PostProcessImage(object sender, EventArgs e)
{
    HttpContext context = ((HttpApplication)sender).Context;
    object cachedPathObject = context.Items[CachedPathKey];

    if (cachedPathObject != null)
    {
        string cachedPath = cachedPathObject.ToString();

        // Fire the post processing event.
        EventHandler<PostProcessingEventArgs> handler = OnPostProcessing;
        if (handler != null)
        {
            context.Items[CachedPathKey] = null;
            return Task.Run(() => handler(this, 
            new PostProcessingEventArgs { CachedImagePath = cachedPath }));
        }
    }

    return Task.FromResult<object>(null);
}

From what I can see below though this seems unwise.

The single purpose of this eventhandler would be to allow someone to run longer running tasks on the file like using something like jpegtran or pngout to post-process an image to further optimize it. What's the best approach for that?

Answer 1

You can add async event handlers using the AddOn* methods in the HttpApplication class. I'm sure that async void methods are not supported by all of them. Maybe by none of them.

To use those methods despite the fact that they do not directly support tasks, you need to adapt your task to be compatible with the APM pattern which ASP.NET uses here.

Maybe it is just sample code but you use of Task.Factory.StartNew is not helpful in the context of a web application.

Answer 2

The key is that you need to avoid async void. There are a couple of places where async void can trip you up.

You're already handling the first one correctly by using EventHandlerTaskAsyncHelper. I assume your setup code looks something like this:

public void Init(HttpApplication context)
{
  var helper = new EventHandlerTaskAsyncHelper(InvokePostAuthEvents);
  context.AddOnPostAuthorizeRequestAsync(helper.BeginEventHandler,
      helper.EndEventHandler);
}

With this kind of setup, you're avoiding an async void PostAuthorizeRequest.

The other side is when you raise the OnPostProcessing event. This is where you are having problems with async void. There are a variety of ways to raise async-aware events (I cover a number of them on my blog), but I prefer the "deferral" method which is used by WinStore apps, so it will likely be more familiar to developers.

I have a DeferralManager in my AsyncEx library that is designed to be used in your event args like this:

public class PostProcessingEventArgs
{
  private readonly DeferralManager _deferrals;

  public PostProcessingEventArgs(DeferralManager deferrals, ...)
  {
    _deferrals = deferrals;
    ...
  }

  public IDisposable GetDeferral()
  {
    return deferrals.GetDeferral();
  }

  ...
}

When you raise the event, you do this:

Task RaisePostProcessingEventAsync()
{
  EventHandler<PostProcessingEventArgs> handler = OnPostProcessing;
  if (handler == null)
    return TaskConstants.Completed;
  var deferrals = new DeferralManager();
  var args = new PostProcessingEventArgs(deferrals) { CachedPath = cachedPath };
  handler(this, args);
  return deferrals.SignalAndWaitAsync();
}

Note that raising the event is now an asynchronous operation, since it will (asynchronously) wait for all the event handler deferrals to complete.

Regular (synchronous) event handlers require no changes, but asynchronous event handlers need to use a deferral, like this:

private async void WritePath(object sender, PostProcessingEventArgs e)
{
  using (e.GetDeferral())
  {
    await Task.Delay(1000);
    Debug.WriteLine(e.CachedPath);
  }
}

As a final note, neither StartNew nor Run is a good idea on ASP.NET. If you have synchronous code to run, just run it directly.

Answer 3

It's complaining that the worker thread hasn't completed before the request thread is terminated. This is a no no... for all it knows your worker thread might not ever terminate, which would lead to thread starvation in a very short space of time.

If you want to have a worker thread you need to create it in the Init of your HttpModule. I think this is a pretty good example...

http://msdn.microsoft.com/en-us/library/hh567803(v=cs.95).aspx

So have a single worker thread that runs for the duration of the module and and let the requests simply add work for the worker thread to process