Passando string JSON complexa a 1 parâmetro webmethod em c # - desearialize em objeto (json.net)?

Question

Eu tenho sido serialização feliz com objetos javascript em JSON usando

         JSON.stringify

E o envio junto ao meu webmethod "estático" em c # / asp.net e certeza enought chega .. Eu preciso o número correto de parâmetros, portanto, se o meu objeto JSON tem "startDate", "endDate", "reserva", em seguida, minha webmethod precisa estes como parâmetros.

"Basicamente com meu objeto para que eu tenho, eu tenho um número de parâmetros sobre este objeto para que eu precisaria usar o mesmo número na webmethod - este é um pouco confuso ??" - Vou explicar

Eu tenho um objeto bastante complexo "Ordem" em javascript e desejo para serializar-lo usando stringify e enviá-lo juntamente à minha webmethod mas eu não quero especificar todos os parâmetros que há uma maneira de contornar isso?

Eu estava esperando por algo como isso no meu webmethod

           public static bool MakeReservation(object order)

Então, em minha webmethod eu só tenho 1 parâmetro mas posso então desearilize a um objeto verdadeiro c # usando JSON.NET. Eu tentei isso assim enviar o json através mas porque há apenas 1 parâmetro no meu webmethod sua falha.

Basicamente o que eu estou tentando dizer se eu que eu quero continuar a usar o meu webmethod mas eu não quero ter que fazer especificar 15 parâmetros na webmethod

Eu quero o JSON - corda para chegar no meu webmethod e então eu posso decompor-lo no servidor

.

Isso é possível?

Aqui está como eu atualmente estou enviando meu JSON para o servidor (webmethod) usando jQuery

    var jsonData = JSONNew.stringify(orderObject);

    $.ajax({
        type: "POST",
        url: "MyService.aspx/DoReservation",
        data: jsonData,
        contentType: "application/json; charset=utf-8",
        dataType: "json",
        success: function(msg) {
            success = true;
        },
        error: function(msg) {
            success = false;
        },
        async: false
    });

Answer 1

Se você tentar enviar um objeto que se parece com isso:

JSON.stringify({ endDate: new Date(2009, 10, 10), startDate: new Date() });

irão tentar mapear endDate e startDate aos parâmetros correspondentes no seu webmethod. Desde que você só quer aceitar um único método, eu suspeito que você pode começar afastado com ele, enviando o seguinte:

JSON.stringify({ order: orderObject });

O que pode razoavelmente tentar atribuir como um valor para o parâmetro 'ordem' do seu webmethod. Na sua falta, a apresentação

JSON.stringify({ order: JSON.stringify(orderObject) });

e, em seguida, desserializar-lo usando JSON.NET deve definitivamente trabalho, mas é mais feio, de modo a tentar o primeiro exemplo em primeiro lugar. Esse é o meu melhor tiro.

Answer 2

É possível. Eu não sou tão bom em coisas explicando, eu vou mostrar-lhe o meu código de exemplo:

Javascript:

var Order = function(name, orderid, price) {
this.name = name;
this.orderid = orderid;
this.price = price;}

var pagePath = window.location.pathname;

function setOrder() {
var jsOrder = new Order("Smith", 32, 150);
var jsonText = JSON.stringify({ order: jsOrder });
$.ajax({
    type: "POST",
    url: pagePath + "/SetOrder",
    contentType: "application/json; charset=utf-8",
    data: jsonText,
    dataType: "json",
    success: function(response) {
        alert("wohoo");
    },
    error: function(msg) { alert(msg); }
});
}

C # Code trás

public class Order
{
 public string name { get; set; }
 public int orderid { get; set; }
 public int price { get; set; }
}

[WebMethod]
public static void SetOrder(object order)
{
    Order ord = GetOrder(order);
    Console.WriteLine(ord.name +","+ord.price+","+ord.orderid);        
}
public static Order GetOrder(object order)
{
    Order ord = new Order();
    Dictionary<string,object> tmp = (Dictionary<string,object>) order;
    object name = null;
    object price = null;
    object orderid = null;
    tmp.TryGetValue("name", out name);
    tmp.TryGetValue("price", out price);
    tmp.TryGetValue("orderid", out orderid);
    ord.name = name.ToString();
    ord.price = (int)price;
    ord.orderid = (int) orderid;
    return ord;
}

Meu código não é tão bonito, mas eu espero que você tenha o significado disso.

Answer 3

I recentemente passou por esta questão com um objeto JSON complexe eu queria deserilize no meu controlador. A única diferença é que eu estava usando o plugin .toJSON no cliente em vez de .stringify.

A resposta fácil:

public static bool MakeReservation(string orderJSON)
{
    var serializer = new JavaScriptSerializer();
    var order = serializer.Deserialize<Order>(orderJSON);
}

Agora, como uma solução de longo prazo criamos um costume ActionFilterAttribute para lidar com esses casos. Ele detecta os parâmetros JSON e alças deserilizing o objeto e mapeamento da ação. Você pode querer olhar em fazer o mesmo.