Respostas jQuery AJAX em ASP.NET MVC

Question

Nem mesmo tenho certeza se este é o caminho certo para o título da pergunta. Eu sei que estou fazendo o meu AJAX chama tudo errado ... aqui é o que eu estou fazendo agora (estou usando o ASP.NET MVC backend por sinal):

Eu uso jQuery.ajax para postar alguns dados para uma ação, que irá carregar uma visão que eu captura na resposta. É basicamente fornecendo alguns dados para uma ação, e tendo alguns de volta HTML.

Vamos dizer que eu queria criar uma chamada Ajax que é validado. Como faço para voltar as mensagens de validação de erro? Por exemplo, um formulário de login Ajax. Se o usuário não pode ser validado, eu gostaria de dizer-lhes que ... em vez de simplesmente não fazer nada.

Desculpem a pergunta ingênua, eu só não sei como a palavra certo para encontrar as soluções no Google.

Agradecemos antecipadamente!

Answer 1

Em primeiro lugar, se você quiser chamada de AJAX para retornar os dados que você está planejando usar em seus scripts (e pelo uso Quero dizer algo mais complicado, em seguida, exibir os dados em um div), você provavelmente deve retornar dados JSON em vez de HTML de seu servidor. JSON é na verdade um objeto JS para que ele possa ser usado em JS no momento em que é recebido.

Então, se você devolver o i de dados.

{id: 1, status: 'ok'}

Você pode usar algo como isto para usar esses dados.

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

Você vai precisar retornar vários pedaços de informações para a sua resposta. Felizmente, você pode fazer isso facilmente usando JSON e jQuery vai lidar com isso automaticamente para você se você diga a ele o tipo de resposta é JSON. O objeto que você entrar em sua função de retorno de ajax irá conter todas as peças de dados que você precisa como propriedades diferentes.

Eu sugeriria começar o hábito de retornar um código de status de "sucesso" ou "fracasso" com cada chamada ajax, e uma coleção de erros com ele. Veja esta postagem no blog incrível para mais informações sobre o que quero dizer.

A razão para isto é que uma chamada de ajax sempre fundamentalmente "sucesso", a menos que o servidor realmente não poderia processar o pedido e retornou um código de status http fracasso. Se o resultado do pedido é algo como um erro de validação, mas o servidor ainda retorna algum tipo de resposta de texto, então a chamada ajax ainda é considerado ter conseguido, mesmo que a operação do aplicativo falhou.

Assim, se, no seu método de ação, em vez de retornar os dados HTML em um resultado de ação, se você retornou um objeto como este:

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

Isso se traduzirá em um objeto javascript que tem propriedades ".Sucesso", ".Data" e ".Erros".

Então, se o seu código de validação tinha povoada a matriz de erros com todos os erros de validação, seria fácil para a sua função de retorno de ajax para

1. determinar que a finalidade pretendida da chamada tinha falhado, porque a propriedade sucesso foi definido como "fracasso".

2. Get todas as cadeias de erro relevante.

Você pode fazer isso facilmente com este tipo de padrão em seus métodos de ação:

    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 sobre esta mesma situação . Talvez ele vai ajudar você na sua situação também. É basicamente sobre ter uma classe de exceção personalizada e um atributo action exceção que irá devolver o erro. Então você é capaz de usar as opções success e error da chamada $.ajax. Que na minha opinião é a maneira certa de fazê-lo.

chamada $.ajax fornece funcionalidade para o sucesso punho, bem como respostas de erro. Não há necessidade de voltar sempre um sucesso com um conjunto de sinalizador de erro que você tem que verificar no cliente.

Answer 4

Eu não tenho certeza se eu entendi completamente o que você quer dizer. Mas o seu exemplo de uma mensagem de validação em um erro, não seria esse trabalho como o seguinte:

1. O usuário clica em algum botão / link tudo o que faz com que uma ação
2. Uma asynchronouse post é feito de volta para o servidor, transmitindo o ID do usuário (você deve estar ciente de segurança aqui)
3. No servidor a validação necessária é feito e uma volta resposta send (em XML, JSON, directamente a mensagem codificada como HTML)
4. Voltar no lado do cliente que você começa a sua resposta em seu código JavaScript e colocá-lo de forma adequada na página

Espero que ajude.