C# JsonResultData.AddException方法代码示例

        public System.Web.Mvc.ActionResult Submit(Sites.Models.Site site, System.Web.Mvc.ControllerContext controllerContext, Sites.Models.SubmissionSetting submissionSetting)
        {
            var request = controllerContext.HttpContext.Request;
            var action = request["action"];

            var jsonResultData = new JsonResultData();
            object result = null;

            try
            {
                if (action == "get-addresses")
                {
                    result = GetAddresses(site, controllerContext);
                }

                jsonResultData.Success = true;
                jsonResultData.Model = result;
            }
            catch (Exception ex)
            {
                jsonResultData.Success = false;
                jsonResultData.AddException(ex);
            }

            return new JsonResult { Data = jsonResultData, JsonRequestBehavior = JsonRequestBehavior.AllowGet };
        }

 public ActionResult Delete(News[] model)
 {
     JsonResultData resultEntry = new JsonResultData();
     try
     {
         foreach (var item in model)
         {
             repository.Delete(item);
         }
         resultEntry.RedirectUrl = Url.Action("Index", ControllerContext.RequestContext.AllRouteValues().Merge("id", null));
     }
     catch (Exception e)
     {
         resultEntry.AddException(e);
     }
     return Json(resultEntry);
 }

        public ActionResult Index(string siteName, ModuleInfo_Metadata moduleInfo)
        {
            JsonResultData resultEntry = new JsonResultData(ModelState);
            try
            {
                if (ModelState.IsValid)
                {
                    ModuleInfo.SaveModuleSetting(ModuleName, siteName, moduleInfo.Settings);
                    resultEntry.AddMessage("Module setting has been changed.".Localize());
                }

            }
            catch (Exception e)
            {
                resultEntry.AddException(e);
            }
            return Json(resultEntry);
        }

        protected ActionResult ReturnActionResult(object model, Exception exception)
        {
            var jsonResult = this.ControllerContext.RequestContext.GetRequestValue("JsonResult");
            string redirectUrl = "";
            if (exception == null)
            {
                redirectUrl = this.ControllerContext.RequestContext.GetRequestValue("SuccessedUrl");
            }
            else
            {
                Session["Exception"] = exception;
                redirectUrl = this.ControllerContext.RequestContext.GetRequestValue("FailedUrl");
            }

            if (jsonResult.EqualsOrNullEmpty("true", StringComparison.OrdinalIgnoreCase))
            {
                var data = new JsonResultData() { Model = model, RedirectUrl = redirectUrl };
                if (exception != null)
                {
                    data.AddException(exception);
                    if ((exception is RuleViolationException))
                    {
                        ((RuleViolationException)exception).FillIssues(this.ModelState);
                        data.AddModelState(this.ModelState);
                    }
                }
                return Json(data);
            }
            if (exception != null && string.IsNullOrEmpty(redirectUrl))
            {
                throw exception;
            }

            if (!string.IsNullOrEmpty(redirectUrl))
            {
                return Redirect(redirectUrl);
            }

            if (this.Request.UrlReferrer != null)
            {
                return Redirect(this.Request.UrlReferrer.OriginalString);
            }
            return new EmptyResult();
        }

        public ActionResult Create(News news, string @return)
        {
            JsonResultData resultEntry = new JsonResultData(ViewData.ModelState);
            try
            {
                if (ModelState.IsValid)
                {
                    repository.Add(news);
                    resultEntry.RedirectUrl = @return;
                }

            }
            catch (Exception e)
            {
                resultEntry.AddException(e);
            }

            return Json(resultEntry);
        }

        public virtual ActionResult Edit(string folderName, string uuid, FormCollection form, string @return, bool localize = false)
        {
            var data = new JsonResultData();
            try
            {
                if (ModelState.IsValid)
                {
                    TextFolder textFolder = new TextFolder(Repository, folderName).AsActual();
                    var schema = textFolder.GetSchema().AsActual();

                    SchemaPath schemaPath = new SchemaPath(schema);
                    IEnumerable<TextContent> addedCategories;
                    IEnumerable<TextContent> removedCategories;

                    ParseCategories(form, out addedCategories, out removedCategories);
                    ContentBase content;

                    content = TextContentManager.Update(Repository, textFolder, uuid, form,
                    Request.Files, DateTime.UtcNow, addedCategories, removedCategories, User.Identity.Name);

                    if (localize == true)
                    {
                        TextContentManager.Localize(textFolder, uuid);
                    }

                    data.RedirectToOpener = true;

                    data.RedirectUrl = @return;

                }
            }
            catch (RuleViolationException violationException)
            {
                foreach (var item in violationException.Issues)
                {
                    ModelState.AddModelError(item.PropertyName, item.ErrorMessage);
                }
                data.Success = false;
            }
            catch (Exception e)
            {
                data.AddException(e);
            }
            data.AddModelState(ModelState);
            return Json(data);
        }

        public virtual ActionResult Create(string folderName, string parentFolder, string parentUUID, FormCollection form, string @return)
        {
            var data = new JsonResultData();
            try
            {
                if (ModelState.IsValid)
                {
                    TextFolder textFolder = new TextFolder(Repository, folderName).AsActual();
                    var schema = textFolder.GetSchema().AsActual();

                    SchemaPath schemaPath = new SchemaPath(schema);
                    IEnumerable<TextContent> addedCategories;
                    IEnumerable<TextContent> removedCategories;

                    ParseCategories(form, out addedCategories, out removedCategories);
                    ContentBase content;

                    content = TextContentManager.Add(Repository, textFolder, parentFolder, parentUUID, form, Request.Files, addedCategories, User.Identity.Name);

                    data.RedirectUrl = @return;
                }
            }
            catch (RuleViolationException ruleEx)
            {
                foreach (var item in ruleEx.Issues)
                {
                    data.AddFieldError(item.PropertyName, item.ErrorMessage);
                }
            }
            catch (Exception e)
            {
                data.AddException(e);
            }
            data.AddModelState(ModelState);
            return Json(data);
        }

        protected override void OnException(ExceptionContext filterContext)
        {
            base.OnException(filterContext);

            if (filterContext.HttpContext.Request.IsAjaxRequest())
            {
                var result = new JsonResultData();
                result.AddException(filterContext.Exception);
                filterContext.Result = Json(result, JsonRequestBehavior.AllowGet);
                filterContext.ExceptionHandled = true;
            }
        }

        public virtual ActionResult Publish(string siteName)
        {
            if(string.IsNullOrWhiteSpace(siteName))
                throw new ArgumentNullException("siteName");

            var site = SiteHelper.Parse(siteName);
            if (site == null)
                throw new NullReferenceException("site");
            site = site.AsActual();
            var rootSite = SiteHelper.GetRootSite(site).AsActual();
            if (string.IsNullOrWhiteSpace(rootSite.ClientId))
                throw new Exception("Customer ID is not specified".Localize());

            var ip = rootSite.FrontendDefaultIp;
            var path = Path.Combine(site.PhysicalPath, rootSite.FrontendPhysicalPath);
            var protocol = rootSite.FrontendDefaultProtocol;
            var port = rootSite.FrontendDefaultPort;
            var appPoolName = rootSite.FrontendDefaultApplicationPoolName;
            var name = site.UID; //string.Format("Frontend.{0}.{1}", rootSite.ClientId, siteName);

            //Chek domain name
            //
            if (site.Domains == null || site.Domains.Length == 0)
            {
                var result = new JsonResultData(ModelState);
                result.AddErrorMessage("Before publish site you must specify the domain name (System/Settings/Domain/Domains)".Localize());
                return Json(result);
            }

            try
            {
                //Create web site
                //
                IISHelper.CreateWebSite(appPoolName, name, protocol, ip, site.Domains.ToArray(), port, path);

            }
            catch (Exception e)
            {
                var result = new JsonResultData();
                result.AddException(new Exception("Fail to publication.".Localize() + " " + e.Message, e));
                return Json(result);
            }

            //Result
            //
            var data = new JsonResultData(ModelState);
            data.ReloadPage = true;
            return Json(data);
        }

        public virtual ActionResult ChangeSiteState(string siteName, string state)
        {
            try
            {
                if (string.IsNullOrWhiteSpace(siteName))
                    throw new ArgumentNullException("siteName");

                if (string.IsNullOrWhiteSpace(state))
                    throw new ArgumentNullException("state");

                var site = SiteHelper.Parse(siteName);
                if (site == null)
                    throw new NullReferenceException("site");
                site = site.AsActual();
                IISHelper.SiteState(site.UID, (StateOperationSite)Enum.Parse(typeof(StateOperationSite), state));
            }
            catch (Exception e)
            {
                var result = new JsonResultData();
                result.AddException(new Exception("Fail change site state.".Localize() + " " + e.Message, e));
                return Json(result);
            }

            //Result
            //
            var data = new JsonResultData(ModelState);
            data.ReloadPage = true;
            return Json(data);
        }