Respuestas jQuery AJAX en ASP.NET MVC

Question

No es seguro si este es el camino correcto a la pregunta del título. Sé que estoy haciendo mi llamadas AJAX todo mal ... esto es lo que estoy haciendo ahora (estoy usando ASP.NET MVC backend por cierto):

Yo uso jQuery.ajax para publicar algunos datos para una acción, que cargará una vista que capturo en la respuesta. Se proporciona básicamente algunos datos para una acción, y tomando algo de HTML espalda.

Digamos que quería crear una llamada Ajax que se valida. ¿Cómo llego de vuelta los mensajes de validación de error? Por ejemplo, un formulario de acceso Ajax. Si el usuario no puede validarse, me gustaría decirles que ... en lugar de simplemente no hacer nada.

Lo siento por la pregunta ingenua, simplemente no sé cómo la palabra bien para encontrar las soluciones de Google.

Gracias de antemano!

Answer 1

En primer lugar si quieres AJAX llamada para regresar los datos que está previsto utilizar en sus scripts (y por el uso me refiero a algo más complicado de lo que muestra que los datos en un div), probablemente debería devolver datos JSON en lugar de HTML desde su servidor. JSON es en realidad un objeto de JS para que pueda ser utilizado en JS el momento en que se recibe.

Así que si devuelve el es decir los datos.

{id: 1, status: 'ok'}

Puede utilizar algo como esto para utilizar esos datos.

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

Tendrá que devolver varias piezas de información por su respuesta. Afortunadamente, usted puede hacerlo fácilmente usando JSON, y jQuery va a manejar automáticamente por usted si le dice que es el tipo de respuesta JSON. El objeto que se obtiene en su función de devolución de llamada Ajax contendrá todos los elementos de datos que necesita tan diferentes propiedades.

Yo sugeriría entrar en el hábito de devolver un código de estado de "éxito" o "fracaso" con cada llamada ajax, y una colección de errores con él. Ver este impresionante entrada de blog para más información en lo que quiero decir.

La razón de esto es que una llamada ajax siempre fundamentalmente "éxito", a menos que el servidor realmente no pudo procesar la solicitud y devolvió un código de estado HTTP fracaso. Si el resultado de la solicitud es algo así como un error de validación, pero el servidor sigue devolviendo algún tipo de respuesta de texto, entonces la llamada AJAX se considera que ha tenido éxito, a pesar de que la operación de aplicación no se pudo.

Así que si, en su método de acción, en lugar de devolver los datos HTML en un resultado de la acción, si se devuelve un objeto como éste:

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

Esto se traducirá en un objeto JavaScript que tiene propiedades ".Success", ".Data" y ".Errors".

Así que si su código de validación se había poblado la matriz de errores con todos los errores de validación, sería fácil para su función de devolución de llamada Ajax a

1. determinar que el destino de la llamada había fracasado, debido a que se establezca la propiedad ÉXITO de "fracaso".

2. Obtener todos las cadenas de error relevantes.

Usted puede hacer esto fácilmente con este tipo de patrón en sus métodos de acción:

    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

blog acerca de esta misma situación . Tal vez le ayudará en su situación así. Se trata básicamente de tener una clase de excepción personalizada y un atributo de acción excepción que devolverá el error. Así que usted es capaz de utilizar las opciones success y error de la llamada $.ajax. ¿Qué es en mi opinión la forma correcta de hacerlo.

llamada $.ajax proporciona funcionalidad para manejar el éxito, así como las respuestas de error. No hay necesidad de volver siempre un éxito con un conjunto indicador de error que usted tiene que comprobar en el cliente.

Answer 4

No estoy seguro de si estoy totalmente entendido lo que quiere decir. Pero el ejemplo de un mensaje de validación en un error, no lo haría que el trabajo como la siguiente:

1. El usuario hace clic en algún botón / enlace de lo que hace que una acción
2. Un puesto asynchronouse se realiza de nuevo al servidor, que transmite el identificador de usuario (debe ser consciente de la seguridad aquí)
3. En el servidor se realiza la validación necesaria y una respuesta de enviar de vuelta (en XML, JSON, directamente el mensaje codificado como HTML)
4. De vuelta en el lado del cliente que obtenga su respuesta en su código JavaScript y colocarlo apropiadamente en la página

Espero que ayude.