Question

I have this handler. I had an exception occuring in the ‘StartTransfer’ method of the inner class (I’ve marked the spot), and for reason I don’t know it went looping this method. Why did it go loops and didn’t just responded in exception message?

public sealed class ImageUploadHandler : IHttpAsyncHandler
{
    public bool IsReusable { get { return false; } }

    public ImageUploadHandler()
    {
    }
    public IAsyncResult BeginProcessRequest(HttpContext context, AsyncCallback cb, Object extraData)
    {
        string token = context.Request.Form["token"];
        string albumId = context.Request.Form["albumId"];
        string imageDescription = context.Request.Form["description"];
        HttpPostedFile imageFile = context.Request.Files["image"];

        ImageTransferOperation ito = new ImageTransferOperation(cb, context, extraData);
        ito.Start(token, albumId, imageDescription, imageFile);
        return ito;
    }

    public void EndProcessRequest(IAsyncResult result)
    {
    }

    public void ProcessRequest(HttpContext context)
    {
        throw new InvalidOperationException();
    }

    private class ImageTransferOperation : IAsyncResult
    {
        private Object state;
        private bool isCompleted;
        private AsyncCallback cb;
        private HttpContext context;

        public WaitHandle AsyncWaitHandle
        {
            get { return null; }
        }

        public bool CompletedSynchronously
        {
            get { return false; }
        }

        public bool IsCompleted
        {
            get { return isCompleted; }
        }

        public Object AsyncState
        {
            get { return state; }
        }

        public ImageTransferOperation(AsyncCallback cb, HttpContext context, Object state)
        {
            this.cb = cb;
            this.context = context;
            this.state = state;
            this.isCompleted = false;
        }

        public void Start(string token, string albumId, string description, HttpPostedFile file)
        {
            Dictionary<string, Object> dictionary = new Dictionary<string,object>(3);

            dictionary.Add("token", token);
            dictionary.Add("albumId", albumId);
            dictionary.Add("description", description);
            dictionary.Add("file", file);

            ThreadPool.QueueUserWorkItem(new WaitCallback(StartTransfer), dictionary);
        }

        private void StartTransfer(Object state)
        {
            Dictionary<string, Object> dictionary = (Dictionary<string, Object>)state;

            string token = (string)dictionary["token"];
            string albumId = (string)dictionary["albumId"];
            string description = (string)dictionary["description"];
            HttpPostedFile file = (HttpPostedFile)dictionary["file"];

            var media = new Facebook.FacebookMediaObject {
                FileName = file.FileName,
                ContentType = file.ContentType                  
            };

            using (var binaryReader = new BinaryReader(file.InputStream))
            {
                media.SetValue(binaryReader.ReadBytes(Convert.ToInt32(file.InputStream.Length)));
            }

            dictionary.Clear();

            dictionary.Add("message", description);
            dictionary.Add("source", media);

            var client = new Facebook.FacebookClient(token); // <-- Here is where the exception occured

            //var result = client.Post("/" + albumId + "/photos", dictionary);

            context.Response.ContentType = "text/plain";

            context.Response.Write(token + " | " + file.FileName);
            //context.Response.Write(result.ToString());

            isCompleted = true;
            cb(this);
        }
    }
}

Answer 1

I can’t honestly explain whatever it is you’re describing as “looping”, but you are mot handling any exceptions in your async code. You must handle exceptions and propagate them back to the thread who is waiting on the IAsyncResult.

So, first, you need to have a try/catch/finally around the majority of the body of the StartTransfer method where you capture any potential exception that might occur, store it in a field and, in the finally block, always invoke the callback. Now that you’re actually capturing any potential exception and always calling back, you will next need to test to see if an exception has occurred in the EndProcessRequest and raise it there so that the callback can “observe” it.

Here’s some revisions to your ImageTransferOperation class:

private Exception asyncException;

public Exception Exception
{
    get
    {
        return this.asyncException;
    }
}

private void StartTransfer(Object state)
{
    try
    {
        ... rest of implementation here ...
    }
    catch(Exception exception)
    {
        this.asyncException = exception;
    }
    finally
    {
        this.isCompleted = true;
        this.cb(this);
    }
}

And then to the ImageUploadHandler to propagate the exception back:

public void EndProcessRequest(IAsyncResult result)
{
    ImageTransferOperation imageTransferOperation = (ImageTransferOperation)result;

    Exception exception = imageTransferOperation.Exception

    if(exception != null)
    {
        throw exception;
    }
}