ASP.NET MVC comment convertir les erreurs ModelState en json

Voici la mise en œuvre complète avec tous les morceaux réunis:

créer D'abord une méthode d'extension:

public static class ModelStateHelper
{
    public static IEnumerable Errors(this ModelStateDictionary modelState)
    {
        if (!modelState.IsValid)
        {
            return modelState.ToDictionary(kvp => kvp.Key,
                kvp => kvp.Value.Errors
                                .Select(e => e.ErrorMessage).ToArray())
                                .Where(m => m.Value.Any());
        }
        return null;
    }
}

ensuite appeler cette méthode d'extension et retourner les erreurs de l'action du contrôleur (s'il y en a) comme json:

if (!ModelState.IsValid)
{
    return Json(new { Errors = ModelState.Errors() }, JsonRequestBehavior.AllowGet);
}

et enfin, montrer ces erreurs du côté du client (en jquery.la validation de style, mais peut facilement être changé à n'importe quel autre style)

function DisplayErrors(errors) {
    for (var i = 0; i < errors.length; i++) {
        $("<label for='" + errors[i].Key + "' class='error'></label>")
        .html(errors[i].Value[0]).appendTo($("input#" + errors[i].Key).parent());
    }
}

j'aime utiliser Hashtable ici, pour obtenir un objet JSON avec des propriétés comme clés et des erreurs comme valeur sous forme de tableau de chaînes de caractères.

var errors = new Hashtable();
foreach (var pair in ModelState)
{
    if (pair.Value.Errors.Count > 0)
    {
        errors[pair.Key] = pair.Value.Errors.Select(error => error.ErrorMessage).ToList();
    }
}
return Json(new { success = false, errors });

de cette façon vous obtenez la réponse suivante:

{
   "success":false,
   "errors":{
      "Phone":[
         "The Phone field is required."
      ]
   }
}

il y a beaucoup de façons différentes de faire cela qui fonctionnent toutes. Voici maintenant, je le fais...

if (ModelState.IsValid)
{
    return Json("Success");
}
else
{
    return Json(ModelState.Values.SelectMany(x => x.Errors));
}

@JK cela m'a beaucoup aidé mais pourquoi pas:

 public class ErrorDetail {

        public string fieldName = "";
        public string[] messageList = null;
 }

        if (!modelState.IsValid)
        {
            var errorListAux = (from m in modelState 
                     where m.Value.Errors.Count() > 0 
                     select
                        new ErrorDetail
                        { 
                                fieldName = m.Key, 
                                errorList = (from msg in m.Value.Errors 
                                             select msg.ErrorMessage).ToArray() 
                        })
                     .AsEnumerable()
                     .ToDictionary(v => v.fieldName, v => v);
            return errorListAux;
        }

regardez le système.Web.Http.Résultat.OkNegotiatedContentResult.

il convertit tout ce qu'on y jette en JSON.

alors j'ai fait ça

var errorList = ModelState.ToDictionary(kvp => kvp.Key.Replace("model.", ""), kvp => kvp.Value.Errors[0].ErrorMessage);

return Ok(errorList);

résultat:

{
  "Email":"The Email field is not a valid e-mail address."
}

je suis encore à vérifier ce qui se passe quand il ya plus d'une erreur pour chaque champ, mais le point est le OkNegoriatedContentResult est brillant!

a obtenu l'idée de linq/lambda de @SLaks

la façon la plus simple de faire cela est de simplement retourner un BadRequest avec le ModelState lui-même:

par exemple sur un PUT :

[HttpPut]
public async Task<IHttpActionResult> UpdateAsync(Update update)
{
    if (!ModelState.IsValid)
    {
        return BadRequest(ModelState);
    }

    // perform the update

    return StatusCode(HttpStatusCode.NoContent);
}

si nous utilisons des annotations de données sur par exemple un numéro mobile, comme celui-ci, dans la classe Update :

public class Update {
    [StringLength(22, MinimumLength = 8)]
    [RegularExpression(@"^\d{8}$|^00\d{6,20}$|^\+\d{6,20}$")]
    public string MobileNumber { get; set; }
}

ceci retournera ce qui suit sur une demande invalide:

{
  "Message": "The request is invalid.",
  "ModelState": {
    "update.MobileNumber": [
      "The field MobileNumber must match the regular expression '^\d{8}$|^00\d{6,20}$|^\+\d{6,20}$'.",
      "The field MobileNumber must be a string with a minimum length of 8 and a maximum length of 22."
    ]
  }
}

ToDictionary est une extension énumérable trouvée dans le système.Linq emballé dans le système.Web.DLL http://msdn.microsoft.com/en-us/library/system.linq.enumerable.todictionary.aspx . Voici à quoi ressemble le cours complet pour moi.

using System.Collections;
using System.Web.Mvc;
using System.Linq;

namespace MyNamespace
{
    public static class ModelStateExtensions
    {
        public static IEnumerable Errors(this ModelStateDictionary modelState)
        {
            if (!modelState.IsValid)
            {
                return modelState.ToDictionary(kvp => kvp.Key,
                    kvp => kvp.Value.Errors.Select(e => e.ErrorMessage).ToArray()).Where(m => m.Value.Count() > 0);
            }
            return null;
        }

    }

}

pourquoi ne pas retourner l'objet original ModelState au client, puis utiliser jQuery pour lire les valeurs. Pour moi, il semble beaucoup plus simple, et utilise la structure de données commune (.net ModelState )

pour retourner le ModelState comme Json, passez-le simplement au constructeur de classe Json (fonctionne avec N'importe quel objet)

C#:

return Json(ModelState);

js:

        var message = "";
        if (e.response.length > 0) {
            $.each(e.response, function(i, fieldItem) {
                $.each(fieldItem.Value.Errors, function(j, errItem) {
                    message += errItem.ErrorMessage;
                });
                message += "\n";
            });
            alert(message);
        }

moyen Simple d'y parvenir en utilisant une fonctionnalité intégrée

[HttpPost]
public IActionResult Post([FromBody]CreateDoctorInput createDoctorInput) {
    if (!ModelState.IsValid) {
        return BadRequest(ModelState);
    }

    //do something
}

JSON résultat sera

Variation avec le type de retour au lieu de retourner IEnumerable

public static class ModelStateHelper
{
    public static IEnumerable<KeyValuePair<string, string[]>> Errors(this ModelStateDictionary modelState)
    {
        if (!modelState.IsValid)
        {
            return modelState
                .ToDictionary(kvp => kvp.Key, kvp => kvp.Value.Errors.Select(e => e.ErrorMessage).ToArray())
                .Where(m => m.Value.Any());
        }

        return null;
    }
}

  List<ErrorList> Errors = new List<ErrorList>(); 


        //test errors.
        var modelStateErrors = this.ModelState.Keys.SelectMany(key => this.ModelState[key].Errors);

        foreach (var x in modelStateErrors)
        {
            var errorInfo = new ErrorList()
            {
                ErrorMessage = x.ErrorMessage
            };
            Errors.Add(errorInfo);

        }

si vous utilisez jsonresult alors retourner""

return Json(Errors);

ou vous pouvez simplement retourner les modelStateErrors, Je ne l'ai pas essayé. Ce que j'ai fait, c'est assigner la collection D'erreurs à mon modèle de vue et ensuite la boucle.dans ce cas, je peux retourner mes erreurs via json. J'ai une classe/modèle, je voulais obtenir la source/clé mais j'essaye toujours de comprendre.

    public class ErrorList
{
    public string ErrorMessage;
}