ASP.NET MVC - Wie werden ModelState-Fehler in RedirectToAction beibehalten?

Ich habe die folgenden zwei Aktionsmethoden (für Fragen vereinfacht):

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

[HttpPost]
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"]});
   }   
}

Wenn die Validierung erfolgreich ist, leite ich auf eine andere Seite um (Bestätigung).

Wenn ein Fehler auftritt, muss ich die gleiche Seite mit dem Fehler anzeigen.

Wenn ich das tue return View(), wird der Fehler angezeigt, aber wenn ich es tue return RedirectToAction(wie oben), verliert es die Modellfehler.

Ich bin nicht überrascht von dem Problem und frage mich nur, wie ihr damit umgeht.

Ich könnte natürlich nur dieselbe Ansicht anstelle der Umleitung zurückgeben, aber ich habe Logik in der "Erstellen" -Methode, die die Ansichtsdaten auffüllt, die ich duplizieren müsste.

Irgendwelche Vorschläge?

Sie müssen dieselbe Instanz von Reviewfür Ihre HttpGetAktion haben. Dazu sollten Sie ein Objekt Review reviewin der temporären Variablen Ihrer HttpPostAktion speichern und es dann bei der HttpGetAktion wiederherstellen .

[HttpGet]
public ActionResult Create(string uniqueUri)
{
   //Restore
   Review review = TempData["Review"] as Review;            

   // get some stuff based on uniqueuri, set in ViewData.  
   return View(review);
}
[HttpPost]
public ActionResult Create(Review review)
{
   //Save your object
   TempData["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"]});
   }   
}

Wenn dies auch dann funktionieren soll, wenn der Browser nach der ersten Ausführung der HttpGetAktion aktualisiert wird , können Sie Folgendes tun:

  Review review = TempData["Review"] as Review;  
  TempData["Review"] = review;

Andernfalls ist das Objekt der Schaltfläche "Aktualisieren" reviewleer, da keine Daten vorhanden sind TempData["Review"].

Ich musste dieses Problem heute selbst lösen und bin auf diese Frage gestoßen.

Einige der Antworten sind nützlich (mithilfe von TempData), beantworten jedoch die vorliegende Frage nicht wirklich.

Der beste Rat, den ich gefunden habe, war in diesem Blog-Beitrag:

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

Verwenden Sie TempData grundsätzlich, um das ModelState-Objekt zu speichern und wiederherzustellen. Es ist jedoch viel sauberer, wenn Sie dies in Attribute abstrahieren.

Z.B

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"]);
        }
    }
}

Dann können Sie gemäß Ihrem Beispiel den ModelState wie folgt speichern / wiederherstellen:

[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"]});
    }   
}

Wenn Sie das Modell auch in TempData weitergeben möchten (wie von bigb vorgeschlagen), können Sie dies auch weiterhin tun.

Warum nicht eine private Funktion mit der Logik in der Methode "Create" erstellen und diese Methode sowohl von der Get- als auch von der Post-Methode aufrufen und einfach View () zurückgeben?

ich könnte benutzen TempData["Errors"]

TempData werden über Aktionen hinweg übergeben, wobei Daten 1 Mal beibehalten werden.

Ich schlage vor, dass Sie die Ansicht zurückgeben und eine Duplizierung über ein Attribut für die Aktion vermeiden. Hier ist ein Beispiel für das Auffüllen zum Anzeigen von Daten. Mit Ihrer Methode zum Erstellen von Methoden können Sie etwas Ähnliches tun.

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
}

Hier ist ein Beispiel:

[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);
}

Ich habe eine Methode, die temporären Daten den Modellstatus hinzufügt. Ich habe dann eine Methode in meinem Basis-Controller, die temporäre Daten auf Fehler überprüft. Wenn sie vorhanden sind, werden sie wieder zu ModelState hinzugefügt.

Mein Szenario ist etwas komplizierter, da ich das PRG-Muster verwende, sodass sich mein ViewModel ("SummaryVM") in TempData befindet und auf meinem Zusammenfassungsbildschirm angezeigt wird. Auf dieser Seite befindet sich ein kleines Formular, mit dem Sie Informationen an eine andere Aktion senden können. Die Komplikation ist darauf zurückzuführen, dass der Benutzer einige Felder in SummaryVM auf dieser Seite bearbeiten muss.

Summary.cshtml enthält die Validierungszusammenfassung, die die von uns erstellten ModelState-Fehler abfängt.

@Html.ValidationSummary()

Mein Formular muss jetzt auf eine HttpPost-Aktion für Summary () POSTEN. Ich habe ein weiteres sehr kleines ViewModel, um bearbeitete Felder darzustellen, und die Modellbindung wird mir diese zur Verfügung stellen.

Die neue Form:

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

und die Aktion ...

[HttpPost]
public ActionResult Summary(EditedItemsVM vm)

Hier mache ich eine Validierung und stelle eine schlechte Eingabe fest, daher muss ich mit den Fehlern zur Seite "Zusammenfassung" zurückkehren. Dafür verwende ich TempData, das eine Umleitung überlebt. Wenn es kein Problem mit den Daten gibt, ersetze ich das SummaryVM-Objekt durch eine Kopie (aber die bearbeiteten Felder wurden natürlich geändert) und führe dann eine RedirectToAction ("NextAction") durch.

// 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");

Die Aktion "Summary Controller", bei der alles beginnt, sucht nach Fehlern in den Tempdata und fügt sie dem Modellstatus hinzu.

[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);
            }
        }

Microsoft hat die Möglichkeit zum Speichern komplexer Datentypen in TempData entfernt, sodass die vorherigen Antworten nicht mehr funktionieren. Sie können nur einfache Typen wie Zeichenfolgen speichern. Ich habe die Antwort von @ asgeo1 so geändert, dass sie wie erwartet funktioniert.

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);
            }
        }
    }
}

Von hier aus können Sie bei Bedarf einfach die erforderlichen Datenanmerkungen zu einer Controller-Methode hinzufügen.

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


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

Ich ziehe es vor, meinem ViewModel eine Methode hinzuzufügen, die die Standardwerte auffüllt:

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...
    }
}

Dann nenne ich es, wann immer ich die Originaldaten wie folgt brauche:

    [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!");
    }