带Angularjs的MVC，ASP.NET身份，EmailService和异步调用

Question

After reviewing and trying many of the suggestions surrounding the error message:

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

I found myself in the situation where even though the call to the MVC accountController actually EXECUTED the desired code (an email was sent to the right place with the right content) and a Try/Catch in the controller method would not 'catch' the error, the AngularJS factory that was initiating the call would receive a server error "page".

Factory:(AngularJS)

InitiateResetRequest: function (email) {
                    var deferredObject = $q.defer();

                    $http.post(
                        '/Account/InitiateResetPassword', { email: email }
                    )
                    .success(function (data) {
                            deferredObject.resolve(data);
                    })
                    .error(function (data) {
                        //This is a stop-gap solution that needs to be fixed..!
                        if (data.indexOf("An asynchronous module or handler completed while an asynchronous operation was still pending.") > 0) {
                            deferredObject.resolve(true);
                        } else {
                            deferredObject.resolve(false);
                        }
                    });
                    return deferredObject.promise;
                }

MVC Controller (C#):

        [HttpPost]
        [AllowAnonymous]
        public async Task<int> InitiateResetPassword(string email)
        {
            try
            {
                _identityRepository = new IdentityRepository(UserManager);
                string callbackUrl = Request.Url.AbsoluteUri.Replace(Request.Url.AbsolutePath, "/account/reset?id=");
                await _identityRepository.InitiatePasswordReset(email, callbackUrl);
                return 0;
            }
            catch(Exception ex)
            {
                Console.WriteLine(ex.ToString());
                return 1;
            }
        }

Identity Repository/InitiatePasswordReset:

 public async Task InitiatePasswordReset(string email, string callbackUrl)
        {
            try
            {
                var u = await _applicationUserManager.FindByEmailAsync(email);

                string passwordResetToken = await GetResetToken(u);
                callbackUrl = callbackUrl + HttpUtility.UrlEncode(passwordResetToken);
                await _applicationUserManager.SendEmailAsync(u.Id, RESET_SUBJECT, string.Format(RESET_BODY, u.FirstName, u.LastName, callbackUrl));
            }
            catch(Exception ex)
            {      //another vain attempt to catch the exception...
                Console.WriteLine(ex.ToString());
                throw ex;
            }
        }

The EmailService injected into the ASP.NET Identity "ApplicationUserManager"

   public class EmailService : IIdentityMessageService
    {
        XYZMailer xyzMailer;
        public EmailService()
        {
            xyzMailer = XYZMailer.getCMRMailer();
        }
        public async Task SendAsync(IdentityMessage message)
        {
            //original code as posted:
            //await Task.FromResult(xyzMailer.SendMailAsync(message));
            //solution from @sirrocco-
            await xyzMailer.SendMailAsync(message);
        }
    }

and finally...the XYZMailer class

class XYZMailer
    {
        #region"Constants"
        private const string SMTP_SERVER = "XYZEXCHANGE.XYZ.local";
        private const string NO_REPLY = "noReply@XYZCorp.com";
        private const string USER_NAME = "noreply";
        private const string PASSWORD = "theMagicP@55word"; //NO, that is not really the password :) 
        private const int SMTP_PORT = 587;
        private const SmtpDeliveryMethod SMTP_DELIVERY_METHOD = SmtpDeliveryMethod.Network;
        #endregion//Constants

        internal XYZMailer()
        {
            //default c'tor
        }

        private static XYZMailer _XYZMailer = null;
        public static XYZMailer getXYZMailer()
        {
            if (_XYZMailer == null)
            {
                _XYZMailer = new XYZMailer();
            }
            return _XYZMailer;
        }

        public async Task<int> SendMailAsync(IdentityMessage message)
        {
#if DEBUG
                message.Body += "<br/><br/>DEBUG Send To: " + message.Destination;
                message.Destination = "me@XYZCorp.com";
#endif
            // Create the message:
            var mail =
                new MailMessage(NO_REPLY, message.Destination)
                {
                    Subject = message.Subject,
                    Body = message.Body,
                    IsBodyHtml = true
                };

            // Configure the client:
            using (SmtpClient client = new SmtpClient(SMTP_SERVER, SMTP_PORT)
            {
                DeliveryMethod = SMTP_DELIVERY_METHOD,
                UseDefaultCredentials = false,
                Credentials = new System.Net.NetworkCredential(USER_NAME, PASSWORD),
                EnableSsl = true
            })
            {
                // Send:
                await client.SendMailAsync(mail);

            }
            return 0;
        }

    }

(note: originally the controller method was simply "public async Task InitiateResetPassword, I added the return type as an attempt to trap the error on the server. At runtime, return 0; does hit (breakpoint) the catch does not get hit and at the client")

At the moment I am simply filtering for the expected error message and telling javascript to treat it as a success. This solution has the benefit of 'actually working'... but it is not 'ideal'.

How do I prevent the error on the server? or alternately, How do I catch the error on the server?

Answer 1

You need to remove await Task.FromResult from EmailService because that makes it so the code executes synchronously instead of async.

As to why the the exception was still raised and bubbled up outside the try/catch - I suspect the Task.FromResult was the culprit here too - if you now raise an exception in SendAsync (just to test it) you should catch in the controller.