¿Cómo pasar datos json POST al método Web API como un objeto?

Trabajar con POST en webapi puede ser complicado! Quisiera agregar a la respuesta correcta..

Se centrará específicamente en POST ya que tratar con GET es trivial. No creo que muchos estarían buscando para resolver un problema con GET con webapis. De todos modos..

Si su pregunta es - En MVC Web Api, ¿cómo- - Usar nombres de métodos de acción personalizados que no sean los verbos HTTP genéricos? - Realizar múltiples publicaciones? - Post múltiples tipos simples? - Post tipos complejos vía jQuery?

Entonces las siguientes soluciones pueden ayudar:

Primero, para usar Métodos de acción personalizados en Web API, agregue una ruta web api como:

public static void Register(HttpConfiguration config)
{
    config.Routes.MapHttpRoute(
        name: "ActionApi",
        routeTemplate: "api/{controller}/{action}");
}

Y luego puedes crear métodos de acción como:

[HttpPost]
public string TestMethod([FromBody]string value)
{
    return "Hello from http post web api controller: " + value;
}

Ahora, ejecute el siguiente jQuery desde la consola de su navegador

$.ajax({
    type: 'POST',
    url: 'http://localhost:33649/api/TestApi/TestMethod',
    data: {'':'hello'},
    contentType: 'application/x-www-form-urlencoded',
    dataType: 'json',
    success: function(data){ console.log(data) }
});

Segundo, para realizar múltiples posts, es simple, crear múltiples métodos de acción y decorar con el atributo [HttpPost]. Utilice [ActionName ("MyAction")] para asignar nombres personalizados, sucesivamente. Llegará a jQuery en el cuarto punto a continuación

En tercer lugar, en primer lugar, no es posible publicar múltiples tipos SIMPLES en una sola acción. Además, existe un formato especial para publicar incluso un tipo simple (aparte de pasar el parámetro en la cadena de consulta o el estilo REST). Este fue el punto que me tenía golpeando la cabeza con los clientes de descanso (como Fiddler y Chrome Avanzada de la extensión del cliente de DESCANSO) y la caza alrededor de la web durante casi 5 horas cuando finalmente, la siguiente URL resultó ser de ayuda. Se cita el contenido relevante para el enlace podría resultar muerto!

Content-Type: application/x-www-form-urlencoded
in the request header and add a = before the JSON statement:
={"Name":"Turbo Tina","Email":"[email protected]"}

PD: ¿Notó la sintaxis peculiar?

Http://forums.asp.net/t/1883467.aspx?The+received+value+is+null+when+I+try+to+Post+to+my+Web+Api

De todos modos, superemos esa historia. Continuando:

Cuarto, publicando tipos complejos a través de jQuery, por supuesto, $.ajax () va a llegar rápidamente en el papel:

Let digamos que el método action acepta un objeto Person que tiene un id y un nombre. Entonces, desde javascript:

var person = { PersonId:1, Name:"James" }
$.ajax({
    type: 'POST',
    url: 'http://mydomain/api/TestApi/TestMethod',
    data: JSON.stringify(person),
    contentType: 'application/json; charset=utf-8',
    dataType: 'json',
    success: function(data){ console.log(data) }
});

Y la acción se verá como:

[HttpPost]
public string TestMethod(Person person)
{
    return "Hello from http post web api controller: " + person.Name;
}

Todo lo anterior, funcionó para mí!! ¡Salud!

He estado jugando con esto y descubrí un resultado bastante extraño. Digamos que tienes propiedades públicas en tu clase en C# como esta:

public class Customer
{
    public string contact_name;
    public string company_name;
}

Entonces debes hacer el JSON.stringify truco como sugerido por Shyju y llamarlo así:

var customer = {contact_name :"Scott",company_name:"HP"};
$.ajax({
    type: "POST",
    data :JSON.stringify(customer),
    url: "api/Customer",
    contentType: "application/json"
});

Sin embargo, si define getters y setters en su clase de esta manera:

public class Customer
{
    public string contact_name { get; set; }
    public string company_name { get; set; }
}

Entonces puedes llamarlo mucho más simple:

$.ajax({
    type: "POST",
    data :customer,
    url: "api/Customer"
});

Esto usa el encabezado HTTP:

Content-Type:application/x-www-form-urlencoded

No estoy muy seguro de lo que está sucediendo aquí, pero parece un error (característica? en el marco. Presumiblemente, los diferentes métodos de enlace están llamando a diferentes "adaptadores", y mientras que el adaptador para application/json uno funciona con propiedades públicas, el otro para datos codificados en forma no lo hace.

Sin embargo, no tengo idea de cuál se consideraría la mejor práctica.

Utilice el JSON.stringify () para obtener la cadena en formato JSON, asegúrese de que al hacer la llamada AJAX pase los atributos mencionados a continuación:

• Tipo de contenido:'application/json'
• Tipo de datos: 'json'

A continuación se muestra el código give jquery para hacer una llamada post ajax asp.net api web:

var product =
    JSON.stringify({
        productGroup: "Fablet",
        productId: 1,
        productName: "Lumia 1525 64 GB",
        sellingPrice: 700
    });

$.ajax({
    URL: 'http://localhost/api/Products',
    type: 'POST',
    contentType: 'application/json',
    dataType: 'json',
    data: product,
    success: function (data, status, xhr) {
        alert('Success!');
    },
    error: function (xhr, status, error) {
        alert('Update Error occurred - ' + error);
    }
});

Asegúrese de que su servicio WebAPI espera un objeto fuertemente escrito con una estructura que coincida con el JSON que está pasando. Y asegúrese de que usted stringify el JSON que está publicando.

Aquí está mi JavaScript (usando AngluarJS):

$scope.updateUserActivity = function (_objuserActivity) {
        $http
        ({
            method: 'post',
            url: 'your url here',
            headers: { 'Content-Type': 'application/json'},
            data: JSON.stringify(_objuserActivity)
        })
        .then(function (response)
        {
            alert("success");
        })
        .catch(function (response)
        {
            alert("failure");
        })
        .finally(function ()
        {
        });

Y aquí está mi Controlador WebAPI:

[HttpPost]
[AcceptVerbs("POST")]
public string POSTMe([FromBody]Models.UserActivity _activity)
{
    return "hello";
}

Siguiente código para devolver datos en el formato json ,en lugar de la API xml-Web 2 :-

Ponga la siguiente línea en el Global.archivo asax

GlobalConfiguration.Configuration.Formatters.JsonFormatter.SerializerSettings.ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore;
        GlobalConfiguration.Configuration.Formatters.Remove(GlobalConfiguration.Configuration.Formatters.XmlFormatter);

@model MVCClient.Models.ProductDetails

@{
    ViewBag.Title = "ProductDetails";
}
<script src="~/Scripts/jquery-1.8.2.min.js"></script>
<script type="text/javascript">

    $(document).ready(function () {
        $("#Save").click(function () {
            var ProductDetails = new Object();
            ProductDetails.ProductName =  $("#txt_productName").val();
            ProductDetails.ProductDetail = $("#txt_desc").val();
            ProductDetails.Price= $("#txt_price").val();
            $.ajax({
                url: "http://localhost:24481/api/Product/addProduct",
                type: "Post",
                dataType:'JSON',
                data:ProductDetails, 

                success: function (data) {
                    alert('Updated Successfully');
                    //window.location.href = "../Index";
                },
                error: function (msg) { alert(msg); }
            });
        });
    });
    </script>
<h2>ProductDetails</h2>

<form id="form1" method="post">
    <fieldset>
        <legend>ProductDetails</legend>


        <div class="editor-label">
            @Html.LabelFor(model => model.ProductName)
        </div>
        <div class="editor-field">

            <input id="txt_productName" type="text" name="fname">
            @Html.ValidationMessageFor(model => model.ProductName)
        </div>

        <div class="editor-label">
            @Html.LabelFor(model => model.ProductDetail)
        </div>
        <div class="editor-field">

            <input id="txt_desc" type="text" name="fname">
            @Html.ValidationMessageFor(model => model.ProductDetail)
        </div>

        <div class="editor-label">
            @Html.LabelFor(model => model.Price)
        </div>
        <div class="editor-field">

            <input id="txt_price" type="text" name="fname">
            @Html.ValidationMessageFor(model => model.Price)
        </div>



        <p>
            <input id="Save" type="button" value="Create" />
        </p>
    </fieldset>

</form>
    <div>
        @Html.ActionLink("Back to List", "Index")
    </div>

</form>



@section Scripts {
    @Scripts.Render("~/bundles/jqueryval")
}

Microsoft dio un buen ejemplo de hacer esto:

Https://docs.microsoft.com/en-us/aspnet/web-api/overview/advanced/sending-html-form-data-part-1

Primero valida la solicitud

if (ModelState.IsValid)

Y luego usar los datos serializados.

Content = new StringContent(update.Status)

Aquí 'Status' es un campo en el tipo complejo. La serialización se realiza por. NET, no hay necesidad de preocuparse por eso.

1) En el lado del cliente puede enviarle http.post request in string like below

var IndexInfo = JSON.stringify(this.scope.IndexTree);
this.$http.post('../../../api/EvaluationProcess/InsertEvaluationProcessInputType', "'" + IndexInfo + "'" ).then((response: any) => {}

2) Luego en su controlador de api web puede deserializarlo

public ApiResponce InsertEvaluationProcessInputType([FromBody]string IndexInfo)
    {
var des = (ApiReceivedListOfObjects<TempDistributedIndex>)Newtonsoft.Json.JsonConvert.DeserializeObject(DecryptedProcessInfo, typeof(ApiReceivedListOfObjects<TempDistributedIndex>));}

3) Su clase ApiReceivedListOfObjects debe ser como la siguiente

public class ApiReceivedListOfObjects<T>
    {
        public List<T> element { get; set; }

    }

4)asegúrese de que su cadena serializada (IndexInfo aquí) se convierta en la siguiente estructura antes de JsonConvert.Comando DeserializeObject en el paso 2

var resp = @"
    {
        ""element"": [
        {
            ""A"": ""A Jones"",
            ""B"": ""500015763""
        },
        {
            ""A"": ""B Smith"",
            ""B"": ""504986213""
        },
        {
            ""A"": ""C Brown"",
            ""B"": ""509034361""
        }
        ]
    }";