Wie erhalte ich alle Fehler von ASP.Net MVC modelState?

Ich möchte alle Fehlermeldungen aus dem modelState erhalten, ohne die Schlüsselwerte zu kennen. Durchlaufen, um alle Fehlermeldungen abzurufen, die der ModelState enthält.

Wie kann ich das machen?

foreach (ModelState modelState in ViewData.ModelState.Values) {
    foreach (ModelError error in modelState.Errors) {
        DoSomethingWith(error);
    }
}

Siehe auch Wie erhalte ich die Sammlung von Modellstatusfehlern in ASP.NET MVC? .

Verwenden von LINQ :

IEnumerable<ModelError> allErrors = ModelState.Values.SelectMany(v => v.Errors);

Aufbauend auf der LINQ-Version, wenn Sie alle Fehlermeldungen zu einer Zeichenfolge zusammenfassen möchten:

string messages = string.Join("; ", ModelState.Values
                                        .SelectMany(x => x.Errors)
                                        .Select(x => x.ErrorMessage));

Ich konnte dies mit einem kleinen LINQ tun,

public static List<string> GetErrorListFromModelState
                                              (ModelStateDictionary modelState)
{
      var query = from state in modelState.Values
                  from error in state.Errors
                  select error.ErrorMessage;

      var errorList = query.ToList();
      return errorList;
}

Die obige Methode gibt eine Liste von Validierungsfehlern zurück.

Weiterführende Literatur:

Lesen aller Fehler aus ModelState in ASP.NET MVC

Während des Debuggens finde ich es nützlich, am Ende jeder meiner Seiten eine Tabelle einzufügen, um alle ModelState-Fehler anzuzeigen.

<table class="model-state">
    @foreach (var item in ViewContext.ViewData.ModelState) 
    {
        if (item.Value.Errors.Any())
        { 
        <tr>
            <td><b>@item.Key</b></td>
            <td>@((item.Value == null || item.Value.Value == null) ? "<null>" : item.Value.Value.RawValue)</td>
            <td>@(string.Join("; ", item.Value.Errors.Select(x => x.ErrorMessage)))</td>
        </tr>
        }
    }
</table>

<style>
    table.model-state
    {
        border-color: #600;
        border-width: 0 0 1px 1px;
        border-style: solid;
        border-collapse: collapse;
        font-size: .8em;
        font-family: arial;
    }

    table.model-state td
    {
        border-color: #600;
        border-width: 1px 1px 0 0;
        border-style: solid;
        margin: 0;
        padding: .25em .75em;
        background-color: #FFC;
    }
 </style>

Wie ich festgestellt habe, können Sie Ausnahmen befolgen, ohne dass Fehlermeldungen festgelegt wurden. Wenn Sie also alle Probleme abfangen, die wirklich erforderlich sind, müssen Sie sowohl die ErrorMessage als auch die Exception abrufen.

String messages = String.Join(Environment.NewLine, ModelState.Values.SelectMany(v => v.Errors)
                                                           .Select( v => v.ErrorMessage + " " + v.Exception));

oder als Erweiterungsmethode

public static IEnumerable<String> GetErrors(this ModelStateDictionary modelState)
{
      return modelState.Values.SelectMany(v => v.Errors)
                              .Select( v => v.ErrorMessage + " " + v.Exception).ToList();

}

Falls jemand die Eigenschaft Name des Modells zurückgeben möchte, um die Fehlermeldung in einer stark typisierten Ansicht zu binden.

List<ErrorResult> Errors = new List<ErrorResult>();
foreach (KeyValuePair<string, ModelState> modelStateDD in ViewData.ModelState)
{
    string key = modelStateDD.Key;
    ModelState modelState = modelStateDD.Value;

    foreach (ModelError error in modelState.Errors)
    {
        ErrorResult er = new ErrorResult();
        er.ErrorMessage = error.ErrorMessage;
        er.Field = key;
        Errors.Add(er);
    }
}

Auf diese Weise können Sie den Fehler tatsächlich mit dem Feld verknüpfen, das den Fehler ausgelöst hat.

Es reichte mir nicht aus, nur die Fehlermeldungen selbst auszugeben, aber das war der Trick.

var modelQuery = (from kvp in ModelState
                  let field = kvp.Key
                  let state = kvp.Value
                  where state.Errors.Count > 0
                  let val = state.Value?.AttemptedValue ?? "[NULL]"

                  let errors = string.Join(";", state.Errors.Select(err => err.ErrorMessage))
                  select string.Format("{0}:[{1}] (ERRORS: {2})", field, val, errors));

Trace.WriteLine(string.Join(Environment.NewLine, modelQuery));

Für den Fall, dass jemand es braucht, habe ich die folgende statische Klasse in meinen Projekten erstellt und verwendet

Anwendungsbeispiel:

if (!ModelState.IsValid)
{
    var errors = ModelState.GetModelErrors();
    return Json(new { errors });
}

Verwendung:

using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Web.Mvc;
using WebGrease.Css.Extensions;

Klasse:

public static class ModelStateErrorHandler
{
    /// <summary>
    /// Returns a Key/Value pair with all the errors in the model
    /// according to the data annotation properties.
    /// </summary>
    /// <param name="errDictionary"></param>
    /// <returns>
    /// Key: Name of the property
    /// Value: The error message returned from data annotation
    /// </returns>
    public static Dictionary<string, string> GetModelErrors(this ModelStateDictionary errDictionary)
    {
        var errors = new Dictionary<string, string>();
        errDictionary.Where(k => k.Value.Errors.Count > 0).ForEach(i =>
        {
            var er = string.Join(", ", i.Value.Errors.Select(e => e.ErrorMessage).ToArray());
            errors.Add(i.Key, er);
        });
        return errors;
    }

    public static string StringifyModelErrors(this ModelStateDictionary errDictionary)
    {
        var errorsBuilder = new StringBuilder();
        var errors = errDictionary.GetModelErrors();
        errors.ForEach(key => errorsBuilder.AppendFormat("{0}: {1} -", key.Key,key.Value));
        return errorsBuilder.ToString();
    }
}

Und das funktioniert auch:

var query = from state in ModelState.Values
    from error in state.Errors
    select error.ErrorMessage;
var errors = query.ToArray(); // ToList() and so on...

Nützlich zum Übergeben einer Reihe von Fehlermeldungen an View, möglicherweise über Json:

messageArray = this.ViewData.ModelState.Values.SelectMany(modelState => modelState.Errors, (modelState, error) => error.ErrorMessage).ToArray();

Dies erweitert die Antwort von @Dunc. Siehe XML-Dokumentkommentare

// ReSharper disable CheckNamespace
using System.Linq;
using System.Web.Mvc;


public static class Debugg
{
    /// <summary>
    /// This class is for debugging ModelState errors either in the quick watch 
    /// window or the immediate window.
    /// When the model state contains dozens and dozens of properties, 
    /// it is impossible to inspect why a model state is invalid.
    /// This method will pull up the errors
    /// </summary>
    /// <param name="modelState">modelState</param>
    /// <returns></returns>
    public static ModelError[]  It(ModelStateDictionary modelState)
    {
        var errors = modelState.Values.SelectMany(x => x.Errors).ToArray();
        return errors;            
    }
}

Darüber hinaus ModelState.Values.ErrorMessagekann leer sein, ModelState.Values.Exception.Messagekann aber auf einen Fehler hinweisen.

In Ihrer Implementierung fehlt Ihnen die statische Klasse, dies sollte sein.

if (!ModelState.IsValid)
{
    var errors =  ModelStateErrorHandler.GetModelErrors(this.ModelState);
    return Json(new { errors });
}

lieber

if (!ModelState.IsValid)
{
    var errors = ModelState.GetModelErrors();
    return Json(new { errors });
}

<div class="text-danger" style="direction:rtl" asp-validation-summary="All"></div>

Verwenden Sie einfach den Asp-Validation-Summary Tag Helper