jQuery AJAX Antworten in ASP.NET MVC

Question

Nicht einmal sicher, ob dies der richtige Weg ist die Frage nach Titel. Ich weiß, ich mache meine AJAX alles falsch ruft ... hier ist, was ich jetzt tun (ich bin mit ASP.NET MVC Backend by the way):

Ich verwende jQuery.ajax einige Daten auf eine Aktion zu schreiben, die eine Ansicht geladen werden kann, die ich in der Antwort erfassen. Es ist im Grunde ein paar Daten auf eine Aktion bereitstellt, und nimmt einige HTML zurück.

Nehmen wir an, ich wollte einen Ajax-Aufruf erstellen, die überprüft wird. Wie erhalte ich die Prüfungsmeldungen auf Fehler zurück? Zum Beispiel kann ein Login-Formular Ajax. Wenn der Benutzer nicht validiert werden kann, würde Ich mag, ihnen zu sagen, dass ... anstatt einfach nichts zu tun.

Sorry für die naive Frage, ich weiß nur nicht, wie zu Wort, um es richtig, die Lösungen auf Google zu finden.

Vielen Dank im Voraus!

Answer 1

Zu allererst, wenn Sie AJAX-Aufruf die Daten zurückzugeben, Sie in Ihren Skripts verwenden möchten (und durch die Verwendung meine ich etwas komplizierter dann diese Daten in einem div Anzeige), sollten Sie wahrscheinlich JSON-Daten zurückgeben anstelle von HTML von Ihrem Server. JSON ist eigentlich ein JS-Objekt, so dass es in dem Moment in JS verwendet werden, es empfangen wird.

Wenn Sie also die Daten, das heißt zurück.

{id: 1, status: 'ok'}

Sie können so etwas wie diese verwenden, um diese Daten zu verwenden.

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

Sie werden mehr Informationen für Ihre Antwort zurückgeben müssen. Zum Glück kann man das mit JSON tun einfach und jQuery wird automatisch für Sie erledigen, wenn Sie es das Antworttyp sagen ist json. Das Objekt, das Sie in Ihren Ajax-Callback-Funktion erhalten alle Stücke von Daten enthalten, die Sie benötigen, wie unterschiedliche Eigenschaften aufweisen.

Ich würde vorschlagen, in die Gewohnheit, immer einen Statuscode von „Erfolg“ der Rücksendung oder „Versagen“ bei jedem Ajax-Aufruf, und eine Sammlung von Fehlern mit ihm. diese ehrfürchtig Blog-Post für weitere Informationen auf das, was ich meine.

Der Grund dafür ist, dass ein Ajax-Aufruf wird immer grundsätzlich „gelingen“, es sei denn, der Server tatsächlich die Anforderung nicht verarbeiten konnte und einen Fehler HTTP-Statuscode zurückgegeben. Wenn das Ergebnis der Anforderung so etwas wie ein Validierungsfehler, aber der Server gibt immer noch eine Art von Text-Antwort, dann wird der Ajax-Aufruf immer noch als gelungen zu sein, auch wenn die Anwendung Vorgang ist fehlgeschlagen.

Also, wenn in Ihrer Aktion-Methode, anstatt Ihre HTML-Daten in einer Aktion Ergebnis der Rückkehr, wenn Sie ein Objekt wie folgt zurückgegeben:

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

Dies wird in ein Javascript-Objekt übersetzen, die Eigenschaften ".Success", ".Data" und ".Errors".

hat

Also, wenn Ihr Validierungscode den Fehler Array mit allen Validierungsfehler bevölkert hätte, wäre es für Ihre Ajax-Callback-Funktion einfach zu

1. bestimmen, dass der beabsichtigte Zweck des Anrufs nicht gelungen war, weil der Erfolg Eigenschaft wurde auf „Fehler“.

2. Get alle die relevanten Fehlerstrings.

Sie können dies mit dieser Art von Muster in den Aktionsmethoden leicht tun:

    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

Ich habe über diese gleiche Situation gebloggt . Vielleicht auch wird es Ihnen in Ihrer Situation helfen. Es ist im Grunde über eine benutzerdefinierte Ausnahmeklasse und eine Ausnahme Aktion Attribut, das den Fehler zurück. Sie sind also der Lage, die success und error Optionen des $.ajax Anruf zu nutzen. Die meiner Meinung nach ist der richtige Weg, es zu tun.

$.ajax Aufruf Funktionen zugegriffen Erfolg sowie Fehlerreaktionen zu behandeln. Keine Notwendigkeit, immer wieder zurückkehrt einen Erfolg mit einem Fehler-Flag gesetzt, die Sie auf dem Client zu überprüfen.

Answer 4

Ich bin mir nicht sicher, ob ich voll und ganz verstanden, was Sie meinen. Aber Ihr Beispiel einer Validierungsnachricht auf einen Fehler, würde das nicht, dass die Arbeit wie folgt aus:

1. Der Benutzer klickt auf einige Button / Link, was auch immer die eine Aktion
Ursachen
2. Ein asynchronouse Post wird auf den Server ausgeführt zurück, die Benutzer-ID übertragen (Sie sollen hier die Sicherheit bewusst sein)
3. Auf dem Server die notwendige Validierung durchgeführt wird, und eine Antwort zurückschicken (in XML, JSON, direkt die Nachricht als HTML codiert)
4. Zurück auf der Client-Seite erhalten Sie Ihre Antwort in Ihrem JavaScript-Code und legen Sie sie in geeigneter Weise auf der Seite

Ich hoffe, das hilft.