jQuery AJAX risposte in ASP.NET MVC

Question

Non è nemmeno sicuro se questo è il modo giusto per titolo la questione. So che sto facendo il mio chiamate AJAX tutto sbagliato ... ecco quello che sto facendo adesso (sto usando ASP.NET MVC backend tra l'altro):

Io uso jQuery.ajax di inviare alcuni dati a un'azione, che caricherà una vista che mi cattura nella risposta. E 'fondamentalmente fornendo alcuni dati a un'azione, e prendendo un po' di HTML indietro.

Diciamo che ho voluto creare una chiamata Ajax che viene convalidato. Come faccio a tornare i messaggi di validazione su errore? Ad esempio, un form di login Ajax. Se l'utente non può essere convalidato, vorrei dire loro che ... invece di fare nulla.

Ci scusiamo per la domanda ingenua, io non so come parola nel modo giusto per trovare le soluzioni su Google.

Grazie in anticipo!

Answer 1

Prima di tutto, se si desidera AJAX chiamata per restituire i dati che si prevede di utilizzare negli script (e per l'uso intendo qualcosa di più complicato poi la visualizzazione di tali dati in un div), probabilmente si dovrebbe restituire i dati JSON invece di HTML dal server. JSON è in realtà un oggetto JS modo che possa essere utilizzato in JS momento in cui viene ricevuto.

Quindi, se si torna al cioè dati.

{id: 1, status: 'ok'}

Si può usare qualcosa di simile a utilizzare tali dati.

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

È necessario restituire più pezzi di informazioni per la tua risposta. Fortunatamente, è possibile farlo facilmente utilizzando JSON, e jQuery verrà automaticamente gestire la cosa per voi, se gli si dice il tipo di risposta è JSON. L'oggetto che si ottiene nella vostra funzione di callback ajax conterrà tutti i pezzi di dati che vi servono come diverse proprietà.

Vi consiglio di prendere l'abitudine di restituire un codice di stato di "successo" o "fallimento" con ogni chiamata ajax, e una collezione di errori con esso. Vedere questo fantastico post sul blog per ulteriori informazioni su quello che voglio dire.

La ragione di questo è che una chiamata AJAX sarà sempre fondamentalmente "successo", a meno che il server è in realtà non ha potuto elaborare la richiesta e restituito un codice di stato HTTP fallimento. Se il risultato della richiesta è qualcosa di simile a un errore di convalida, ma il server restituisce ancora un qualche tipo di risposta di testo, quindi la chiamata AJAX è ancora considerato di essere riuscito, anche se l'operazione di applicazione non è riuscito.

Quindi, se, nel vostro metodo di azione, invece di restituire i dati HTML in un risultato di azione, se si ritorna un oggetto come questo:

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

Questo si tradurrà in un oggetto JavaScript che ha proprietà ".success", ".Data" e ".Errors".

Quindi, se il codice di convalida aveva popolato la matrice degli errori con tutti gli errori di convalida, sarebbe facile per la vostra funzione di callback Ajax per

1. determinare che la destinazione della chiamata era fallito, perché la proprietà successo è stato impostato su "fallimento".

2. Get tutti le relative stringhe di errore.

Si potrebbe fare questo facilmente con questo tipo di modello nei vostri metodi d'azione:

    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

bloggato su questa stessa situazione . Forse vi aiuterà nella vostra situazione pure. E 'fondamentalmente di avere una classe di eccezione personalizzata e un attributo action eccezione che restituirà l'errore. Quindi, siete in grado di utilizzare le opzioni success e error della chiamata $.ajax. Che è a mio parere il modo giusto di farlo.

chiamata $.ajax non fornire funzionalità per gestire il successo così come risposte di errore. Non c'è bisogno di restituire sempre un successo con un set di flag di errore che si controlla sul client.

Answer 4

Non sono sicuro se ho pienamente capito quello che vuoi dire. Ma il vostro esempio di un messaggio di convalida su un errore, non sarebbe che il lavoro come il seguente:

1. l'utente fa clic sul pulsante di alcuni / link qualunque cosa che provoca un'azione
2. Un messaggio asynchronouse è fatto al server, trasmettendo l'ID utente (è necessario essere consapevoli della sicurezza qui)
3. Sul server la validazione necessaria è fatto e una risposta di inviare di nuovo (in XML, JSON, direttamente il messaggio codificato in formato HTML)
4. Torna sul lato client si ottiene la risposta nel codice Javascript e posizionare in modo appropriato sulla pagina

La speranza che aiuta.