private static async Task<HttpResponseMessage> HandleAsyncCore(IExceptionHandler handler,
            ExceptionHandlerContext context, CancellationToken cancellationToken)
        {
            Contract.Assert(handler != null);
            Contract.Assert(context != null);

            await handler.HandleAsync(context, cancellationToken);

            IHttpActionResult result = context.Result;

            if (result == null)
            {
                return null;
            }

            HttpResponseMessage response = await result.ExecuteAsync(cancellationToken);

            if (response == null)
            {
                throw new InvalidOperationException(Error.Format(SRResources.TypeMethodMustNotReturnNull,
                    typeof(IHttpActionResult).Name, "ExecuteAsync"));
            }

            return response;
        }

 // Create the error info object to be returned to the requestor
 public override void Handle(ExceptionHandlerContext context)
 {
     context.Result =
         new ResponseMessageResult
         (context.Request.CreateResponse(HttpStatusCode.InternalServerError,
         new ErrorInfo { Message = context.Exception.Message, Timestamp = DateTime.Now }));
 }

 public virtual bool ShouldHandle(ExceptionHandlerContext context)
 {
     //WebAPI v2 does not use IsOutermostCatchBlock anymore
     //IsOutermostCatchBlock does not exists. Use CatchBlock.IsTopLevel instead:
     //http://stackoverflow.com/a/22357634/1616023
     return context.ExceptionContext.CatchBlock.IsTopLevel;
 }

        private static void Handle(ExceptionHandlerContext context)
        {
            if (context == null)
            {
                throw new ArgumentNullException("context");
            }

            ExceptionContext exceptionContext = context.ExceptionContext;
            Contract.Assert(exceptionContext != null);
            Exception exception = exceptionContext.Exception;

            HttpRequestMessage request = exceptionContext.Request;

            if (request == null)
            {
                throw new ArgumentException(Error.Format(SRResources.TypePropertyMustNotBeNull,
                    typeof(ExceptionContext).Name, "Request"), "context");
            }

            if (exceptionContext.CatchBlock == ExceptionCatchBlocks.IExceptionFilter)
            {
                // The exception filter stage propagates unhandled exceptions by default (when no filter handles the
                // exception).
                return;
            }

            context.Result = new ResponseMessageResult(request.CreateErrorResponse(HttpStatusCode.InternalServerError,
                exception));
        }

        public override void Handle(ExceptionHandlerContext context)
        {
            bool shouldHandle = this.ShouldHandle(context);
            if (!shouldHandle)
            {
                return;
            }

            ErrorContext errorContext = null;

            try
            {
                errorContext = ErrorContextService.Resolve(context);

                var model = new ErrorViewModel(errorContext, context.RequestContext.RouteData.Values);
                var jsonModel = model.ToJson();

                var response = context.Request.CreateResponse(errorContext.HttpStatusCode, jsonModel);

                context.Result = new ResponseMessageResult(response);
            }
            finally
            {
                ErrorContextService.Log(CurrentLogger, errorContext);
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="context"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public virtual Task HandleAsync(ExceptionHandlerContext context, CancellationToken cancellationToken)
        {
            var info = ExceptionDispatchInfo.Capture(context.Exception);
            info.Throw();

            return Task.FromResult(0);
        }

 public override void Handle(ExceptionHandlerContext context)
 {
     if (context.Exception is Code.ExceptionResponse)
     {
         Code.ExceptionResponse ex = context.Exception as Code.ExceptionResponse;
         context.Result = new TextPlainErrorResult
         {
             Request = context.ExceptionContext.Request,
             Content = Transfer.Response.Error(ex.Message)
         };
     }
     else if (context.Exception is Code.ExceptionMaintenance)
     {
         context.Result = new TextPlainErrorResult
         {
             Content = Transfer.Response.Maintenance("Server is down for maintenance")
         };
     }
     else
     {
         context.Result = new TextPlainErrorResult
         {
             Request = context.ExceptionContext.Request,
             Content = Transfer.Response.Error(context.Exception.Message)
         };
     }
 }

        public override void Handle(ExceptionHandlerContext context)
        {
            HttpRequestMessage request = context.Request;


            context.Result = new ResponseMessageResult(request.CreateResponse(HttpStatusCode.InternalServerError, new ErrorMsg(context.Exception.Message)));
        }

 public Task HandleAsync(ExceptionHandlerContext context, CancellationToken cancellationToken)
 {
     // For exceptions at the top of the call stack, Result will start out non-null (due to
     // LastChanceExceptionHandler). This class does not force exceptions back to unhandled in such cases, so it
     // will not not trigger the host-level exception processing, such as the ASP.NET yellow screen.
     return TaskHelpers.Completed();
 }

 private void HandleValidationException(ExceptionHandlerContext context)
 {
     context.Result = new GlobalExceptionResponse(context.ExceptionContext.Request, HttpStatusCode.BadRequest)
     {
         Message = context.Exception.Message
     };
 }

        public override void Handle(ExceptionHandlerContext context)
        {
            var exception = context.Exception;
            var httpException = exception as HttpException;
            if (httpException != null)
            {
                context.Result = new SimpleErrorResult(context.Request, (HttpStatusCode)httpException.GetHttpCode(),
                    httpException.Message);
                return;
            }

            if (exception is RootObjectNotFoundException)
            {
                context.Result = new SimpleErrorResult(context.Request, HttpStatusCode.NotFound,
                exception.Message);
                return;
            }
            if (exception is ChildObjectNotFoundException)
            {
                context.Result = new SimpleErrorResult(context.Request, HttpStatusCode.Conflict,
                exception.Message);
                return;
            }
            context.Result = new SimpleErrorResult(context.Request, HttpStatusCode.InternalServerError, exception.Message);
        }

        public override void Handle(ExceptionHandlerContext context)
        {
            // get base exception
            var baseExp = context.Exception.GetBaseException();

            // set the result
            context.Result = new InternalServerErrorPlainTextResult(baseExp.Message, context.Request);
        }

        /// <summary>
        /// 在衍生類別中覆寫時，同步處理例外狀況。
        /// </summary>
        /// <param name="context">例外狀況處理常式內容。</param>
        public override void Handle(ExceptionHandlerContext context)
        {
            IError error = ErrorFactory.GetExceptionType(context);

            context.Result = new ResponseMessageResult(error.GenerateExceptionMessage(context));

            base.Handle(context);
        }

        public Task HandleAsync(ExceptionHandlerContext context, CancellationToken cancellationToken)
        {
            var jsonResult = "Error Global";

            context.Result = new ResponseMessageResult(new HttpResponseMessage { StatusCode = HttpStatusCode.InternalServerError, Content = new StringContent(jsonResult) });

            return Task.FromResult(0);
        }

 /// <summary>
 /// Format the result of the error context to be send back.
 /// </summary>
 /// <param name="context"></param>
 public override void Handle(ExceptionHandlerContext context)
 {
     context.Result = new TextPlainErrorResult
     {
         Request = context.ExceptionContext.Request,
         Content = $"We apologize but an unexpected error occurred. Please try again later. {context.Exception.Message}"
     };
 }

        /// <summary>
        /// Gets the type of the exception.
        /// </summary>
        /// <param name="context">The context.</param>
        /// <returns>ICustomExceptionHandler</returns>
        public static ICustomExceptionHandler GetExceptionType(ExceptionHandlerContext context)
        {
            var exceptionType = ExceptionCategory
                               .FirstOrDefault(x => x.ExceptionType
                                                     .Equals(context.Exception.GetType().Name));

            return exceptionType ?? new OtherCategory();
        }

 public override void Handle(ExceptionHandlerContext context)
 {
     context.Result = new PlainExceptionResult
     {
         Request = context.ExceptionContext.Request,
         Exception = context.Exception
     };
 }

 public Task HandleAsync(ExceptionHandlerContext context, CancellationToken cancellationToken)
 {
     if (context.CatchBlock != ExceptionCatchBlocks.HttpServer)
     {
         context.Result = null;
     }
     return Task.FromResult(0);
 }

        /// <summary>
        /// Gets the type of the exception.
        /// </summary>
        /// <param name="context">The context.</param>
        /// <returns>ICustomExceptionHandler</returns>
        public static IError GetExceptionType(ExceptionHandlerContext context)
        {
            var exceptionType = ExceptionCategory
                               .FirstOrDefault(x => x.ExceptionType
                                                     .Equals(context.Exception.GetType().Name));

            return exceptionType ?? new UnexpectError();
        }

 public override void HandleCore(ExceptionHandlerContext context)
 {
     context.Result = new TextPlainErrorResult
     {
         Request = context.ExceptionContext.Request,
         Content = "Oops! Something went wrong."
     };
 }