Les réponses jQuery AJAX dans ASP.NET MVC

Question

Même pas sûr si cela est la bonne façon de titre la question. Je sais que je fais mon AJAX appelle tout faux ... voici ce que je fais en ce moment (j'utilise backend ASP.NET MVC par la voie):

J'utilise jQuery.ajax pour poster des données à une action qui va charger une vue que je capture dans la réponse. Il est essentiellement fournir des données à une action, et de prendre un certain HTML dos.

Disons que je voulais créer un appel Ajax qui est validé. Comment puis-je récupérer les messages de validation en cas d'erreur? Par exemple, un formulaire de connexion Ajax. Si l'utilisateur ne peut pas être validé, je voudrais leur dire que ... au lieu de faire simplement rien.

Désolé pour la question naïve, je ne sais pas comment le libeller droit de trouver les solutions sur Google.

Merci d'avance!

Answer 1

Tout d'abord si vous voulez appeler AJAX pour retourner les données que vous envisagez d'utiliser dans vos scripts (et par l'utilisation que je veux dire quelque chose de plus compliqué puis afficher les données dans un div), vous devriez probablement retourner des données JSON au lieu de HTML à partir de votre serveur. JSON est en fait un objet JS il peut donc être utilisé dans JS moment où il est reçu.

Donc, si vous retournez la i.e. de données.

{id: 1, status: 'ok'}

Vous pouvez utiliser quelque chose comme cela d'utiliser ces données.

$.ajax({
    url: "your/script/url",
    type: "POST",
    data: {login : 'foo', pass: 'bar'}, // whatever the data is
    dataType: "json",
    success: function(data){
        if (data.status === 'ok') {
            console.log('success');
        } else {
            console.log('error');
        }
    }

});

Answer 2

Vous devrez renvoyer plusieurs éléments d'information pour votre réponse. Heureusement, vous pouvez le faire facilement en utilisant JSON, et jQuery il gérer automatiquement pour vous si vous dites que ce type de réponse est JSON. L'objet que vous obtenez dans votre fonction de rappel ajax contiendra toutes les pièces de données dont vous avez besoin des propriétés que différentes.

Je vous conseille de prendre l'habitude de retourner un code d'état de la « réussite » ou « échec » à chaque appel ajax, et une collection d'erreurs avec elle. Voir ce blog génial pour plus d'informations sur ce que je veux dire.

La raison est qu'un appel ajax sera toujours fondamentalement « réussir », à moins que le serveur ne pouvait réellement traiter la demande et a renvoyé un code d'état HTTP d'échec. Si le résultat de la demande est quelque chose comme une erreur de validation, mais le serveur retourne encore une sorte de réponse de texte, l'appel ajax est toujours considéré avoir réussi, même si l'opération d'application a échoué.

Donc, si, dans votre méthode d'action, au lieu de retourner vos données html dans un résultat de l'action, si vous êtes retourné un objet comme celui-ci:

public class AjaxResponse
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="AjaxResponse"/> class.
        /// This creates an AjaxResponse that by default indicates SUCCESS.
        /// </summary>
        public AjaxResponse()
        {
            Success = true;
            Data = new List<object>();
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="AjaxResponse"/> class.
        /// This creates an AjaxResponse that indicates FAILURE.
        /// </summary>
        /// <param name="exception">The exception.</param>
        public AjaxResponse(Exception exception)
            : this()
        {
            Success = false;
            Errors = new [] { exception.Message };
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="AjaxResponse"/> class.
        /// This creates an AjaxResponse that indicates SUCCESS.
        /// </summary>
        /// <param name="data">The data.</param>
        public AjaxResponse(object data)
            : this()
        {
            Data = data;
        }

        /// <summary>
        /// Gets or sets a value indicating whether this <see cref="AjaxResponse"/> is success.
        /// </summary>
        /// <value><c>true</c> if success; otherwise, <c>false</c>.</value>
        public bool Success
        {
            get; set;
        }

        /// <summary>
        /// Gets or sets the data.
        /// </summary>
        /// <value>The data.</value>
        public object Data
        {
            get; set;
        }

        /// <summary>
        /// Gets or sets the errors.
        /// </summary>
        /// <value>The errors.</value>
        public string[] Errors
        {
            get; set;
        }
    }

Cela se traduira par un objet javascript qui a des propriétés ".success", ".Data" et ".Errors".

Donc, si votre code de validation avait rempli le tableau des erreurs avec toutes les erreurs de validation, il serait facile pour votre fonction de rappel ajax à

1. déterminer que la destination de l'appel avait échoué, parce que le

   propriété de succès a été réglé sur « l'échec ».

2. Get tous les chaînes d'erreur pertinentes.

Vous pouvez le faire facilement avec ce genre de modèle dans vos méthodes d'action:

    try
    {
        instance.Validate();
        return Json(new AjaxResponse(myHtmlData));
    }
    catch(Exception ex)
    {
        var response = new AjaxResponse(ex);

        // Get your validation errors here, put them into
        // your ajax response's Errors property.

        return Json(response);
    }

Answer 3

J'ai blogué sur cette même situation . Peut-être que cela vous aidera dans votre situation aussi bien. Il est essentiellement d'avoir une classe d'exception personnalisée et un attribut d'action d'exception qui renverra l'erreur. Donc, vous êtes en mesure d'utiliser les options de success et error de l'appel $.ajax. Ce qui est à mon avis la bonne façon de le faire.

appel $.ajax fournit des fonctionnalités pour gérer le succès, ainsi que les réponses d'erreur. Pas besoin de retourner toujours un succès avec un jeu de drapeau d'erreur que vous devez vérifier sur le client.

Answer 4

Je ne sais pas si je bien compris ce que vous voulez dire. Mais votre exemple d'un message de validation sur une erreur, ne serait pas que le travail comme suit:

1. L'utilisateur clique sur une touche / lien quelconque qui provoque une action
2. Un poste asynchronouse est fait sur le serveur, transmettant l'ID utilisateur (vous devez être conscient de la sécurité ici)
3. Sur le serveur de validation nécessaire est fait et une réponse renvoyer (en XML, JSON, directement le message codé en HTML)
4. Retour sur le côté client que vous obtenez votre réponse dans votre code JavaScript et placez correctement sur la page

L'espoir qui aide.