C# Mvc.HandleErrorInfo类代码示例

        public override void OnException(ExceptionContext filterContext)
        {

            if (filterContext == null) throw new ArgumentNullException("filterContext");
            if (filterContext.ExceptionHandled || !filterContext.HttpContext.IsCustomErrorEnabled) return;
            var exception = filterContext.Exception;
            if (new HttpException(null, exception).GetHttpCode() != 500) return;
            var controllerName = (string)filterContext.RouteData.Values["controller"];
            var actionName = (string)filterContext.RouteData.Values["action"];
            var model = new HandleErrorInfo(filterContext.Exception, controllerName, actionName);
            ActionResult result;
            if (IsJson)
                result = new JsonResult { Data = new { error = filterContext.Exception.Message }, JsonRequestBehavior = JsonRequestBehavior.AllowGet };
            else {
                var dict = new ViewDataDictionary<HandleErrorInfo>(model);
                if (filterContext.Controller.ViewData.ContainsKey("KatushaUser")) dict.Add("KatushaUser", filterContext.Controller.ViewData["KatushaUser"]);
                if (filterContext.Controller.ViewData.ContainsKey("KatushaProfile")) dict.Add("KatushaProfile", filterContext.Controller.ViewData["KatushaProfile"]);
                dict.Add("HasLayout", HasLayout);
                result = new ViewResult { ViewName = ExceptionView, ViewData = dict, TempData = filterContext.Controller.TempData };
            }
            filterContext.Result = result;
            filterContext.ExceptionHandled = true;
            filterContext.HttpContext.Response.Clear();
            filterContext.HttpContext.Response.StatusCode = 500;
            filterContext.HttpContext.Response.TrySkipIisCustomErrors = true;
        }

 public ActionResult BadRequest(string error)
 {
     var controllerName = (string)RouteData.Values["controller"];
     var actionName = (string)RouteData.Values["action"];
     var model = new HandleErrorInfo(new HttpException(500, error), controllerName, actionName);
     return View(model);
 }

        public void OnException(ExceptionContext filterContext)
        {
            // Log should go here
            if (filterContext.HttpContext.IsCustomErrorEnabled && !filterContext.ExceptionHandled)
            {
                string controllerName = (string)filterContext.RouteData.Values["controller"];
                string actionName = (string)filterContext.RouteData.Values["action"];
                HandleErrorInfo info = new HandleErrorInfo(filterContext.Exception, controllerName, actionName);

                filterContext.ExceptionHandled = true;
                filterContext.HttpContext.Response.Clear();
                filterContext.HttpContext.Response.StatusCode = 500;
                filterContext.HttpContext.Response.TrySkipIisCustomErrors = true; 

                if (!filterContext.HttpContext.Request.IsAjaxRequest())
                {
                    var errorModel = new ErrorModel(filterContext.Exception.Message, filterContext.Exception, controllerName, actionName);
                    filterContext.Result = new ViewResult { ViewName = "Error" , ViewData = new ViewDataDictionary(errorModel), TempData = filterContext.Controller.TempData };
                }
                else
                {
                    // It should return an JSON response and application should be prepared to display it
                }

            }
        }

        //Handles Exceptions in the Code
        public override void OnException(ExceptionContext filterContext)
        {
            filterContext.ExceptionHandled = true;
            var model = new HandleErrorInfo(filterContext.Exception, "Controller", "Action");

            //var directory = Path.GetFullPath("Log/ExceptionLog.txt");
            //StreamWriter LogWriter = new StreamWriter(directory, true);
            //LogWriter.WriteLine("{0}, {1}, {2}, {3}, {4}", DateTime.Now, filterContext.Exception.Message, filterContext.Exception.InnerException, filterContext.RouteData.Values["controller"], filterContext.RouteData.Values["action"]);
            //LogWriter.WriteLine("-----------------------------------------------------------------------------");
            //LogWriter.Close();

            if (filterContext.HttpContext.IsCustomErrorEnabled)
            {
                if (filterContext.HttpContext.Request.IsAjaxRequest())
                {
                    //if the request is an ajax request return the _Error view
                    filterContext.Result = new ViewResult()
                    {
                        ViewName = "_Error",
                        ViewData = new ViewDataDictionary(model)
                    };
                }
                else
                {
                    //if the request is not an ajax request return the Error view
                    filterContext.Result = new ViewResult()
                    {
                        ViewName = "Error",
                        ViewData = new ViewDataDictionary(model)
                    };
                }
            }
        }

        protected sealed override void HandleUnauthorizedRequest(AuthorizationContext filterContext)
        {
            string resultMessage = HandleUnauthorizedMessage();
            string resultResource = BuildAuthorizeResource(filterContext);

            // Log Access Denied
            if (Token != null) // Don't log anonymous
                AuthorizationLog.LogAccessDenied(Token.User.UserId, resultResource, resultMessage);

            // Build Response View
            var ex = new AccessDeniedException(resultMessage, resultResource);
            HandleErrorInfo model = new HandleErrorInfo(ex, filterContext.ActionDescriptor.ControllerDescriptor.ControllerName, filterContext.ActionDescriptor.ActionName);
            ViewResult result = new ViewResult
            {
                ViewName = "Error",
                MasterName = Token == null ? "_PublicLayout" : "_Layout",
                ViewData = new ViewDataDictionary<HandleErrorInfo>(model),
                TempData = filterContext.Controller.TempData
            };

            filterContext.Result = result;
            var contextResponse = filterContext.HttpContext.Response;
            contextResponse.Clear();
            contextResponse.StatusCode = (int)HttpStatusCode.Unauthorized;
            contextResponse.TrySkipIisCustomErrors = true;
        }

    public override void OnException(ExceptionContext filterContext)
    {
        if (filterContext.ExceptionHandled) return;
        if (new HttpException(null, filterContext.Exception).GetHttpCode() != 500) return;
        if (!ExceptionType.IsInstanceOfType(filterContext.Exception)) return;

        string controllerName = filterContext.GetController();
        string actionName = filterContext.GetAction();
        HandleErrorInfo model = new HandleErrorInfo(filterContext.Exception, controllerName, actionName);

        filterContext.Result = new ViewResult
        {
            ViewName = View,
            MasterName = Master,
            ViewData = new ViewDataDictionary<HandleErrorInfo>(model)
        };

        //使用log4net写入本地日志
        _logger.Error(filterContext.Exception.Message, filterContext.Exception);

        filterContext.HttpContext.Response.Clear();
        filterContext.HttpContext.Response.StatusCode = 500;
        filterContext.HttpContext.Response.TrySkipIisCustomErrors = true;
        filterContext.ExceptionHandled = true;
    }

        public static void HandleException(this ExceptionContext filterContext)
        {
            var ex = filterContext.Exception;
            var contextResponse = filterContext.HttpContext.Response;

            LogException(ex);

            HttpException httpException = new HttpException(null, ex);
            int httpExceptionCode = httpException.GetHttpCode();

            string controllerName = (string)filterContext.RouteData.Values["controller"];
            string actionName = (string)filterContext.RouteData.Values["action"];
            HandleErrorInfo model = new HandleErrorInfo(ex, controllerName ?? "Unknown", actionName ?? "Unknown");
            ViewResult result = new ViewResult
            {
                ViewName = "Error",
                MasterName = "_Layout",
                ViewData = new ViewDataDictionary<HandleErrorInfo>(model),
                TempData = filterContext.Controller.TempData
            };
            
            filterContext.Result = result;
            filterContext.ExceptionHandled = true;
            contextResponse.Clear();
            contextResponse.StatusCode = httpExceptionCode;
            contextResponse.TrySkipIisCustomErrors = true;
        }

        public ActionResult AddActivity(CRM_KA_ActivityModel ActivityModel, string CustomerID)
        {
            try
            {
                if (ModelState.IsValid)
                {
                    ActivityModel.Id = System.Guid.NewGuid();
                    ActivityModel.CustomerID = CustomerID;

                    _KeyAccountManager.saveActivity(ActivityModel);
                    updateKeyAccount(CustomerID);

                    ViewData["CustomerID"] = CustomerID;

                    return PartialView("_KA_ActivityList");
                }
                else
                {
                    throw new Exception();
                }
            }
            catch (Exception ex)
            {
                var modal = new HandleErrorInfo(ex, "KeyAccount", "Index");
                return View("Error", modal);
            }
        }

 // GET: Error
 public ActionResult Index()
 {
     //If a 404 is thrown, the system redirects here but without a HandleErrorInfo object, so we make our own.
     HttpException err = new HttpException(404, string.Format("404 - Unrecognized Url - ({0})", Request.Params["aspxerrorpath"]));
     HandleErrorInfo model = new HandleErrorInfo(err, "Error", "Index");
     return View("Error", model);
 }

        public ActionResult Login(string userId, string password)
        {
            AccountInfo info = new AccountInfo();

            if (ModelState.IsValid)
            {
                info.userid = userId;
                info.password = password;
                try {
                    using (svcClient = new AccountServiceClient())
                    {
                        if (svcClient.Authenticate(info))
                        {
                            Session["IsAuthenticated"] = true;
                            Session["User"] = userId;
                            return View("LoggedIn");
                        }
                    }
                }
                catch (FaultException<AccountServiceFault> ex)
                {
                    HandleErrorInfo errorInfo = new HandleErrorInfo(ex, "Home", "Login");
                    return View("Error", errorInfo);
                }

            }
            ViewBag.LoginFailed = "Oops... user credential is not matched, please try again!";
            return View();
        }

        public override void OnException(ExceptionContext filterContext)
        {
            if (filterContext == null)
            {
                throw new ArgumentNullException("filterContext");
            }

            // If custom errors are disabled, we need to let the normal ASP.NET exception handler
            // execute so that the user can see useful debugging information.
            if (filterContext.ExceptionHandled || !filterContext.HttpContext.IsCustomErrorEnabled)
            {
                return;
            }

            Exception exception = filterContext.Exception;

            // If this is not an HTTP 500 (for example, if somebody throws an HTTP 404 from an action method),
            // ignore it.
            if (new HttpException(null, exception).GetHttpCode() != 500)
            {
                return;
            }

            if (!ExceptionType.IsInstanceOfType(exception))
            {
                return;
            }

            string controllerName = (string)filterContext.RouteData.Values["controller"];
            string actionName = (string)filterContext.RouteData.Values["action"];
            HandleErrorInfo model = new HandleErrorInfo(filterContext.Exception, controllerName, actionName);

            if (this._logger.IsErrorEnabled)
            {
                this._logger.Error(string.Format("An unexpected error occured while executing {0} in {1}.", actionName, controllerName), exception);
            }

            MessageViewData messageViewData = new MessageViewData();

            while (exception != null)
            {
                messageViewData.AddErrorMessage(this._localizer.GetString(exception.Message));
                exception = exception.InnerException;
            }
            var viewData = new ViewDataDictionary<HandleErrorInfo>(model);
            viewData["Messages"] = messageViewData;

            // Render error view
            filterContext.Result = new ViewResult
                                   	{
                                   		ViewName = View,
                                   		MasterName = Master,
                                   		ViewData = viewData,
                                   		TempData = filterContext.Controller.TempData
                                   	};

            filterContext.ExceptionHandled = true;
            filterContext.HttpContext.Response.Clear();
            filterContext.HttpContext.Response.StatusCode = 500;
        }

        public ActionResult CreateTechnicalSupport(TechnicalSupportModel entity)
        {
            if (_TechnicalSupportManager.getByID(entity.VisitedDate,entity.CustomerID,User.Identity.Name)!=null)
            {
                ModelState.AddModelError("*", "This Customer and Visited date are duplicated in record.");
                return View(new TechnicalSupportModel { CustomerID = entity.CustomerID }).WithErrorMessage("Duplicated record!");
            }
            try
            {
                // TODO: Add insert logic here
                entity.AttachGroupID = Guid.NewGuid();
                entity.CreatedBy = User.Identity.Name;
                entity.CreatedDate = DateTime.Today;

                _TechnicalSupportManager.Save(entity);

                List<FileAttachmentModel> FAList = (List<FileAttachmentModel>)Session["Attachment"];

                if (FAList != null)
                {
                    foreach (FileAttachmentModel item in FAList)
                    {
                        _FileAttachmentManager.Save(item,entity.AttachGroupID,User.Identity.Name);
                    }
                }
                return RedirectToAction("Index");
            }
            catch (Exception ex)
            {
                var modal = new HandleErrorInfo(ex, "TechnicalSupport", "CreateTechnicalSupport");
                return View("Error", modal);
            }
        }

        /// <summary>
        /// 异常处理
        /// </summary>
        /// <param name="filterContext">当前请求</param>
        protected override void OnException(ExceptionContext filterContext)
        {
            Exception exception = filterContext.Exception;
            string message;
            if (filterContext.HttpContext.Request.IsAjaxRequest())
            {
                if (exception is HttpAntiForgeryException)
                {
                   
                }
                //filterContext.Result = Json(new AjaxResult(message, AjaxResultType.Error));
                //filterContext.ExceptionHandled = true;
            }
            else
            {

                var error = new HandleErrorInfo(
                    exception,
                    filterContext.RouteData.Values["controller"].ToString(),
                    filterContext.RouteData.Values["action"].ToString());

                filterContext.Result = View("Error", error);
                filterContext.ExceptionHandled = true;
            }
        }

 public virtual void OnException(ExceptionContext filterContext)
 {
     if (filterContext == null)
     {
         throw new ArgumentNullException("filterContext");
     }
     if (!filterContext.IsChildAction && (!filterContext.ExceptionHandled && filterContext.HttpContext.IsCustomErrorEnabled))
     {
         Exception innerException = filterContext.Exception;
         if ((new HttpException(null, innerException).GetHttpCode() == 404))
         {
             string controllerName = (string)filterContext.RouteData.Values["controller"];
             string actionName = (string)filterContext.RouteData.Values["action"];
             HandleErrorInfo model = new HandleErrorInfo(filterContext.Exception, controllerName, actionName);
             ViewResult result = new ViewResult
             {
                 ViewName = this.View,
                 MasterName = this.Master,
                 ViewData = new ViewDataDictionary<HandleErrorInfo>(model),
                 TempData = filterContext.Controller.TempData
             };
             filterContext.Result = result;
             filterContext.ExceptionHandled = true;
             filterContext.HttpContext.Response.Clear();
             filterContext.HttpContext.Response.StatusCode = 404;
             filterContext.HttpContext.Response.TrySkipIisCustomErrors = true;
             filterContext.HttpContext.Response.ClearHeaders();
         }
     }
 }

        public ContentResult addAuthenticatedUser(string UserID)
        {
            try
            {
                if (ModelState.IsValid)
                {
                     HttpCookie CK = HttpContext.Request.Cookies.Get("LoginDetail");

                     if (CK != null)
                     {
                         SecurityUserModel entity = new SecurityUserModel();
                         entity.UserID = UserID;
                         entity.SubsystemID = Int32.Parse(CK.Values["SubSystemID"].ToString());

                         _SecurityManager.Save(entity);

                         return Content("success");
                     }
                     else
                     {
                         return Content("fail");
                     }
                }
                else
                {
                    throw new Exception();
                }
            }
            catch (Exception ex)
            {
                var modal = new HandleErrorInfo(ex, "SecuritySetting", "index");
                return Content("fail");
            }
        }