ASP.NET MVC - ¿Cómo Preservar los Errores de ModelState En RedirectToAction?

Tuve que resolver este problema hoy mismo, y me encontré con esta pregunta.

Algunas de las respuestas son útiles (usando TempData), pero realmente no responden a la pregunta en cuestión.

El mejor consejo que encontré fue en esta entrada del blog:

Http://www.jefclaes.be/2012/06/persisting-model-state-when-using-prg.html

Básicamente, utilice TempData para guardar y restaurar el objeto ModelState. Sin embargo, es mucho más limpio si abstrae esto en atributo.

Por ejemplo

public class SetTempDataModelStateAttribute : ActionFilterAttribute
{
    public override void OnActionExecuted(ActionExecutedContext filterContext)
    {
        base.OnActionExecuted(filterContext);         
        filterContext.Controller.TempData["ModelState"] = 
           filterContext.Controller.ViewData.ModelState;
    }
}

public class RestoreModelStateFromTempDataAttribute : ActionFilterAttribute
{
    public override void OnActionExecuting(ActionExecutingContext filterContext)
    {
        base.OnActionExecuting(filterContext);
        if (filterContext.Controller.TempData.ContainsKey("ModelState"))
        {
            filterContext.Controller.ViewData.ModelState.Merge(
                (ModelStateDictionary)filterContext.Controller.TempData["ModelState"]);
        }
    }
}

Luego, según su ejemplo, podría guardar / restaurar el ModelState de la siguiente manera:

[HttpGet]
[RestoreModelStateFromTempData]
public ActionResult Create(string uniqueUri)
{
    // get some stuff based on uniqueuri, set in ViewData.  
    return View();
}

[HttpPost]
[SetTempDataModelState]
public ActionResult Create(Review review)
{
    // validate review
    if (validatedOk)
    {
        return RedirectToAction("Details", new { postId = review.PostId});
    }  
    else
    {
        ModelState.AddModelError("ReviewErrors", "some error occured");
        return RedirectToAction("Create", new { uniqueUri = Request.RequestContext.RouteData.Values["uniqueUri"]});
    }   
}

Si también desea pasar el modelo en TempData (como sugirió bigb), puede hacerlo también.

¿Por qué no crear una función privada con la lógica en el método "Create" y llamar a este método desde el método Get y el Post y simplemente hacer return View().

Podría usar TempData["Errors"]

Los datos temporales se pasan a través de acciones conservando los datos 1 vez.

Le sugiero que devuelva la vista y evite la duplicación a través de un atributo en la acción. Aquí hay un ejemplo de rellenar para ver datos. Podrías hacer algo similar con la lógica del método create.

public class GetStuffBasedOnUniqueUriAttribute : ActionFilterAttribute
{
    public override void OnActionExecuting(ActionExecutingContext filterContext)
    {
        var filter = new GetStuffBasedOnUniqueUriFilter();

        filter.OnActionExecuting(filterContext);
    }
}


public class GetStuffBasedOnUniqueUriFilter : IActionFilter
{
    #region IActionFilter Members

    public void OnActionExecuted(ActionExecutedContext filterContext)
    {

    }

    public void OnActionExecuting(ActionExecutingContext filterContext)
    {
        filterContext.Controller.ViewData["somekey"] = filterContext.RouteData.Values["uniqueUri"];
    }

    #endregion
}

Aquí hay un ejemplo:

[HttpGet, GetStuffBasedOnUniqueUri]
public ActionResult Create()
{
    return View();
}

[HttpPost, GetStuffBasedOnUniqueUri]
public ActionResult Create(Review review)
{
    // validate review
    if (validatedOk)
    {
        return RedirectToAction("Details", new { postId = review.PostId });
    }

    ModelState.AddModelError("ReviewErrors", "some error occured");
    return View(review);
}

Tengo un método que agrega el estado del modelo a los datos temporales. Luego tengo un método en mi controlador base que comprueba los datos temporales en busca de errores. Si los tiene, los agrega de nuevo a ModelState.

Mi escenario es un poco más complicado ya que estoy usando el patrón PRG, por lo que mi ViewModel ("SummaryVM") está en TempData, y mi pantalla de Resumen lo muestra. Hay un pequeño formulario en esta página para publicar información sobre otra Acción. La complicación ha venido de un requisito para que el usuario edite algunos campos en resumen en esta página.

Resumen.cshtml tiene el resumen de validación que capturará los errores de ModelState que crearemos.

@Html.ValidationSummary()

Mi formulario ahora necesita publicar en un Acción HttpPost para Summary (). Tengo otro ViewModel muy pequeño para representar los campos editados, y modelbinding me los dará.

La nueva forma:

@using (Html.BeginForm("Summary", "MyController", FormMethod.Post))
{
    @Html.Hidden("TelNo") @* // Javascript to update this *@

Y la acción...

[HttpPost]
public ActionResult Summary(EditedItemsVM vm)

Aquí hago algunas validaciones y detecto algunas entradas incorrectas, por lo que necesito volver a la página de Resumen con los errores. Para ello utilizo TempData, que sobrevivirá a una redirección. Si no hay ningún problema con los datos, sustituyo el objeto SummaryVM por una copia (pero con los campos editados cambiado por supuesto) luego haga un RedirectToAction ("NextAction");

// Telephone number wasn't in the right format
List<string> listOfErrors = new List<string>();
listOfErrors.Add("Telephone Number was not in the correct format. Value supplied was: " + vm.TelNo);
TempData["SummaryEditedErrors"] = listOfErrors;
return RedirectToAction("Summary");

La acción Summary controller, donde comienza todo esto, busca cualquier error en los tempdata y los agrega al modelstate.

[HttpGet]
[OutputCache(Duration = 0)]
public ActionResult Summary()
{
    // setup, including retrieval of the viewmodel from TempData...


    // And finally if we are coming back to this after a failed attempt to edit some of the fields on the page,
    // load the errors stored from TempData.
        List<string> editErrors = new List<string>();
        object errData = TempData["SummaryEditedErrors"];
        if (errData != null)
        {
            editErrors = (List<string>)errData;
            foreach(string err in editErrors)
            {
                // ValidationSummary() will see these
                ModelState.AddModelError("", err);
            }
        }

Prefiero agregar un método a mi ViewModel que rellene los valores predeterminados:

public class RegisterViewModel
{
    public string FirstName { get; set; }
    public IList<Gender> Genders { get; set; }
    //Some other properties here ....
    //...
    //...

    ViewModelType PopulateDefaultViewData()
    {
        this.FirstName = "No body";
        this.Genders = new List<Gender>()
        {
            Gender.Male,
            Gender.Female
        };

        //Maybe other assinments here for other properties...
    }
}

Entonces lo llamo cuando necesito los datos originales como este:

    [HttpGet]
    public async Task<IActionResult> Register()
    {
        var vm = new RegisterViewModel().PopulateDefaultViewValues();
        return View(vm);
    }

    [HttpPost]
    public async Task<IActionResult> Register(RegisterViewModel vm)
    {
        if (!ModelState.IsValid)
        {
            return View(vm.PopulateDefaultViewValues());
        }

        var user = await userService.RegisterAsync(
            email: vm.Email,
            password: vm.Password,
            firstName: vm.FirstName,
            lastName: vm.LastName,
            gender: vm.Gender,
            birthdate: vm.Birthdate);

        return Json("Registered successfully!");
    }

Microsoft eliminó la capacidad de almacenar tipos de datos complejos en TempData, por lo tanto, las respuestas anteriores ya no funcionan; solo puede almacenar tipos simples como cadenas. He alterado la respuesta de @asgeo1 para que funcione como se esperaba.

public class SetTempDataModelStateAttribute : ActionFilterAttribute
{
    public override void OnActionExecuted(ActionExecutedContext filterContext)
    {
        base.OnActionExecuted(filterContext);

        var controller = filterContext.Controller as Controller;
        var modelState = controller?.ViewData.ModelState;
        if (modelState != null)
        {
            var listError = modelState.Where(x => x.Value.Errors.Any())
                .ToDictionary(m => m.Key, m => m.Value.Errors
                .Select(s => s.ErrorMessage)
                .FirstOrDefault(s => s != null));
            controller.TempData["KEY HERE"] = JsonConvert.SerializeObject(listError);
        }
    }

public class RestoreModelStateFromTempDataAttribute : ActionFilterAttribute
{
    public override void OnActionExecuting(ActionExecutingContext filterContext)
    {
        base.OnActionExecuting(filterContext);

        var controller = filterContext.Controller as Controller;
        var tempData = controller?.TempData?.Keys;
        if (controller != null && tempData != null)
        {
            if (tempData.Contains("KEY HERE"))
            {
                var modelStateString = controller.TempData["KEY HERE"].ToString();
                var listError = JsonConvert.DeserializeObject<Dictionary<string, string>>(modelStateString);
                var modelState = new ModelStateDictionary();
                foreach (var item in listError)
                {
                        modelState.AddModelError(item.Key, item.Value ?? "");
                }

                controller.ViewData.ModelState.Merge(modelState);
            }
        }
    }        
}
}

Desde aquí, simplemente puede agregar la anotación de datos requerida en un método de controlador según sea necesario.

[RestoreModelStateFromTempDataAttribute]
    [HttpGet]
    public async Task<IActionResult> MethodName()
    {
    }

[SetTempDataModelStateAttribute]
    [HttpPost]
    public async Task<IActionResult> MethodName()
    {
            ModelState.AddModelError("KEY HERE", "ERROR HERE");
    }