El parámetro Post es siempre nulo

He estado rascándome la cabeza sobre esto hoy.

Mi solución es cambiar el [FromBody] a un HttpRequestMessage, esencialmente moviendo hacia arriba la pila HTTP.

En mi caso, estoy enviando datos a través del cable que está comprimido json que luego es base64'd. Todo esto desde una aplicación para Android.

La firma original de mi punto final web se veía así (usando [FromBody]) :

Mi solución para este problema fue volver a usar un HttpRequestMessage para la firma de mi punto final.

Luego puede obtener acceso a los datos de post usando esta línea de código:

Esto funciona y le permite acceder a los datos de post sin tocar. No tienes que perder el tiempo con fiddler poniendo un signo = al principio de tu cadena o cambiando el tipo de contenido.

Como un aparte, primero traté de seguir una de las respuestas anteriores que fue cambiar el tipo de contenido a: "Content-Type: application/x-www-form-urlencoded". Para datos brutos este es un mal consejo porque elimina + caracteres.

Así que una cadena base64 que comienza así:" MQ0AAB+LCAAAAAA "termina así"MQ0AAB LCAAAAA"! No es lo que quieres.

Otra ventaja de usar HttpRequestMessage es que obtiene acceso a todas las cabeceras http desde su endpoint.

Acabo de tener esto ocurrir usando Fiddler. El problema era que no había especificado Content-Type.

Intenta incluir un encabezado para Content-Type en tu solicitud POST.

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

Alternativamente, según los comentarios a continuación, es posible que deba incluir un encabezado JSON

Content-Type: application/json

También me he encontrado con este problema, y así es como resolví mi problema

Código Webapi:

public void Post([FromBody] dynamic data)
{
    string value = data.value;
    /* do stuff */
}

Código de cliente:

$.post( "webapi/address", { value: "some value" } );

Estaba usando Postman y estaba cometiendo el mismo error.. pasar el value como objeto json en lugar de string

{
    "value": "test"
}

Claramente el anterior es incorrecto cuando el parámetro api es de tipo string.

Entonces, simplemente pase la cadena entre comillas dobles en el cuerpo de la api:

"test"

Intente crear una clase que sirva como modelo de datos y, a continuación, envíe un objeto JSON con propiedades que coincidan con las propiedades de su clase de modelo de datos. (Nota: He probado esto y funciona con el nuevo MVC 4 RC 2012 que acabo de descargar hoy).

public HttpResponseMessage Post(ValueModel model)
{
    return Request.CreateResponse<string>(HttpStatusCode.OK, "Value Recieved: " + model.Value);
}

public class ValueModel
{
    public string Value { get; set; }
}

El siguiente objeto JSON se envía en HTTP-POST body, content-type es application / json

{ "value": "In MVC4 Beta you could map to simple types like string, but testing with RC 2012 I have only been able to map to DataModels and only JSON (application/json) and url-encoded (application/x-www-form-urlencoded body formats have worked. XML is not working for some reason" }

Creo que la razón por la que tiene que crear una clase de modelo de datos es porque se supone que los valores simples provienen de los parámetros de url, y se supone que un único valor complejo proviene del cuerpo. Tienen los atributos [FromBody] y [FromUrl], pero usar [FromBody] string value todavía no funcionó para mí. Parece que todavía están resolviendo muchos errores, así que estoy seguro de que esto cambiará en el futuro.

Editar: Tengo XML para trabajar en el cuerpo. El serializador XML predeterminado se cambió a DataContractSerializer en lugar de XmlSerializer. Poniendo la siguiente línea en mi Global.archivo asax solucionado este problema (referencia)

GlobalConfiguration.Configuration.Formatters.XmlFormatter.UseXmlSerializer = true;

Estaba buscando una solución a este problema desde hace unos minutos, así que voy a compartir mi solución.

Si publica un modelo, su modelo necesita tener un constructor vacío/predeterminado, de lo contrario el modelo no se puede crear, obviamente. Tenga cuidado al refactorizar. ;)

Después de algunos intentos, creo que el comportamiento predeterminado es correcto y no hay nada que hackear.

El único truco es: si su argumento del método post es string como a continuación, debe enviar una cadena simple con comillas dobles en el cuerpo (cuando se usa ajax o postman), por ejemplo,

//send "{\"a\":1}" in body to me, note the outer double quotes
[HttpPost("api1")]
public String PostMethod1([FromBody]string value)
{
    return "received " + value; //  "received {\"a\":1}"
}

De lo contrario, si envía una cadena json en el cuerpo del mensaje sin comillas dobles externas y comillas internas escapadas, entonces debería poder analizarse a la clase model (el tipo de argumento), por ejemplo, {"a":1, "b":2}

public class MyPoco{
    public int a;
    public int b;
}

//send {"a":1, "b":2} in body to me
[HttpPost("api2")]
public String PostMethod2([FromBody]MyPoco value)
{
    return "received " + value.ToString();  //"received your_namespace+MyPoco"
}

Tuve el mismo problema y descubrí que al cambiar el tipo de contenido a "application/json" no solucionaba el problema. Sin embargo "application / json; charset = utf-8" funcionó.

Tuve un problema similar en el que el objeto de solicitud para mi método Web API siempre era nulo. Me di cuenta de que, dado que el nombre de la acción del controlador tenía el prefijo "Get", Web API lo trató como un HTTP GET en lugar de como un POST. Después de cambiar el nombre de la acción del controlador, ahora funciona como estaba previsto.

Esto funcionó para mí:

1. Cree una clase DTO de C#, con una propiedad para cada atributo que desee pasar desde jQuery/Ajax

   public class EntityData
   {
       public string Attr1 { get; set; }
       public string Attr2 { get; set; }
   }
   

2. Defina el método web api:

   [HttpPost()]
   public JObject AddNewEntity([FromBody] EntityData entityData)
   {
   

3. Llame a la web api como tal:

   var entityData = {
       "attr1": "value1",
       "attr2": "value2"
   };
   
   $.ajax({
       type: "POST",
       url: "/api/YOURCONTROLLER/addnewentity",
       async: true,
       cache: false,
       data: JSON.stringify(entityData),
       contentType: "application/json; charset=utf-8",
       dataType: "json",
       success: function (response) {
           ...
       }
   });
   

En mi caso el problema era que el parámetro era una cadena y no un objeto, cambié el parámetro a JObject de Newsoft.Json y funciona.

Para aquellos que tienen el mismo problema con Swagger o Postman como lo hice yo, si está pasando un atributo simple como cadena en un mensaje, incluso con el "ContentType" especificado, aún obtendrá un valor nulo.

Pasando solo:

MyValue

Aparecerá en el controlador como null.

Pero si pasas:

"MyValue"

El valor saldrá bien.

Las citas hicieron la diferencia aquí. Por supuesto, esto es sólo para Swagger y Cartero. Para instancia, en una aplicación Frontend utilizando Angular esto debe ser resuelto por el marco de trabajo de forma automática.

Añadiendo la línea

        ValueProviderFactories.Factories.Add(new JsonValueProviderFactory());

Al final de la función protected void Application_Start() en Global.asax.cs solucionado un problema similar para mí en ASP.NET MVC3.

Con Angular, pude pasar datos en este formato:

 data: '=' + JSON.stringify({ u: $scope.usrname1, p: $scope.pwd1 }),
 headers: { 'Content-Type': 'application/x-www-form-urlencoded; charset=utf-8' }

Y en Web API Controlador:

    [HttpPost]
    public Hashtable Post([FromBody]string jsonString)
    {
        IDictionary<string, string> data = JsonConvert.DeserializeObject<IDictionary<string, string>>(jsonString);
        string username = data["u"];
        string pwd = data["p"];
   ......

Alternativamente, también podría publicar datos JSON como este:

    data: { PaintingId: 1, Title: "Animal show", Price: 10.50 } 

Y, en el controlador, acepte un tipo de clase como este:

    [HttpPost]
    public string POST(Models.PostModel pm)
    {

     ....
    }

De cualquier manera funciona, si tiene una clase pública establecida en la API, entonces publique JSON, de lo contrario publique '=' + JSON.stringify ({..: ..., .. : ... })

Si está utilizando un DataContractSerializer para su Formateador Xml o Formateador JSON, debe deshacerse de él. Tenía esto en mi archivo WebApiConfig:

public static void Register(HttpConfiguration config)
{
     config.Routes.MapHttpRoute(
           name: "DefaultApi",
           routeTemplate: "api/{controller}/{id}",
           defaults: new { id = RouteParameter.Optional }
     );    

     var jsonFormatter = config.Formatters.OfType<JsonMediaTypeFormatter>().First();
     jsonFormatter.UseDataContractJsonSerializer = true;
}

Simplemente comento jsonFormatter.UseDataContractJsonSerializer = true; y mi parámetro de entrada ya no es null. Gracias a Despertar por darme una pista.

Sé que esto no es una respuesta a esta pregunta, pero me encontré con ella cuando busqué una solución a mi problema.

En mi caso, el tipo complejo no estaba siendo enlazado pero no estaba haciendo un POST, estaba haciendo un GET con parámetros querystring. La solución fue añadir [FromUri] al arg:

public class MyController : ApiController
{
    public IEnumerable<MyModel> Get([FromUri] MyComplexType input)
    {
        // input is not null as long as [FromUri] is present in the method arg
    }
}

Tuve el mismo problema en Fiddler. Ya tenía Content-Type: application/json; charset=utf-8 o Content-Type: application/json en el encabezado de la solicitud.

Mi cuerpo de la petición era también una cuerda llana, y en Fiddler había escrito: {'controller':'ctrl'}. Esto hizo que el parámetro string en mi método POST sea null.

Fix : recuerde usar comillas, indicando así una cadena. Es decir, lo arreglé escribiendo "{'controller':'ctrl'}". (Nota: al escribir JSON, asegúrese de usar apóstrofos o escape las comillas así: "{\"controller\":\"ctrl\"}").

La forma más sencilla que encontré para tratar con un objeto JSON simple que paso a MVC 6 es obtener el tipo del parámetro post como NewtonSoft JObject:

public ActionResult Test2([FromBody] jObject str)
{
        return Json(new { message = "Test1 Returned: "+ str }); ;
}

La mejor solución para mí es ir HTTP completo como a continuación:

[Route("api/open")]
[HttpPost]
public async Task<string> open(HttpRequestMessage request)
{
    var json = await request.Content.ReadAsStringAsync();
    JavaScriptSerializer jss = new JavaScriptSerializer();            
    WS_OpenSession param = jss.Deserialize<WS_OpenSession>(json);
    return param.sessionid;
}

Y luego deserializar la cadena al objeto que espera en el cuerpo del post. Para mí, WS_OpenSession es una clase que contiene sessionid, user y key.

Desde allí puede usar el objeto param y acceder a sus propiedades.

Muy muy eficaz.

Dije que proviene de esta url:

Http://bizcoder.com/posting-raw-json-to-web-api

Si está seguro de su JSON enviado, debe rastrear su API cuidadosamente:

1. Instalar Microsoft.AspNet.WebApi.Tracing paquete
2. Agregue config.EnableSystemDiagnosticsTracing(); en la clase WebApiConfig dentro del método Register.

Ahora mire la salida de depuración y probablemente encontrará una entrada de registro ModelState no válida.

Si ModelState no es válido, puede encontrar la causa real en su Errors:

Nadie puede siquiera adivinar tal excepción:

Could not load file or assembly 'Newtonsoft.Json, Version=9.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed' or one of its dependencies. The located assembly's manifest definition does not match the assembly reference. (Exception from HRESULT: 0x80131040)

Para tipos complejos, Web API intenta leer el valor del cuerpo del mensaje, utilizando un formateador de tipo media.

Por favor, compruebe si tiene algún atributo [Serializable] decorando su clase modelo.

Elimine el atributo para ver si funciona. Esto funcionó para mí.

Llego un poco tarde a la fiesta, pero cualquiera que tropiece con un valor NULL pasado al usar un controlador simplemente agrega "=" al frente de tu solicitud de PUBLICACIÓN.

El controlador también pasó un valor NULL cuando usé el application/json Content-Type. Observe el tipo de contenido" application/x-www-form-urlencoded " a continuación. Sin embargo, el tipo de retorno de la API es "application/json".

 public static string HttpPostRequest(string url, Dictionary<string, string> postParameters)
    {
        string postData = "=";

        foreach (string key in postParameters.Keys)
        {
            postData += HttpUtility.UrlEncode(key) + "="
                  + HttpUtility.UrlEncode(postParameters[key]) + ",";
        }

        HttpWebRequest myHttpWebRequest = (HttpWebRequest)HttpWebRequest.Create(url);
        myHttpWebRequest.Method = "POST";

        byte[] data = System.Text.Encoding.ASCII.GetBytes(postData);

        myHttpWebRequest.ContentType = "application/x-www-form-urlencoded";
        myHttpWebRequest.ContentLength = data.Length;

        Stream requestStream = myHttpWebRequest.GetRequestStream();
        requestStream.Write(data, 0, data.Length);
        requestStream.Close();

        HttpWebResponse myHttpWebResponse = (HttpWebResponse)myHttpWebRequest.GetResponse();

        Stream responseStream = myHttpWebResponse.GetResponseStream();

        StreamReader myStreamReader = new StreamReader(responseStream, System.Text.Encoding.Default);

        string pageContent = myStreamReader.ReadToEnd();

        myStreamReader.Close();
        responseStream.Close();

        myHttpWebResponse.Close();

        return pageContent;
    }

No importa qué tipo de valor desea publicar, simplemente enciérrelo entre comillas, para obtenerlo como cadena. No para tipos complejos.

Javascript:

    var myData = null, url = 'api/' + 'Named/' + 'NamedMethod';

    myData = 7;

    $http.post(url, "'" + myData + "'")
         .then(function (response) { console.log(response.data); });

    myData = "some sentence";

    $http.post(url, "'" + myData + "'")
         .then(function (response) { console.log(response.data); });

    myData = { name: 'person name', age: 21 };

    $http.post(url, "'" + JSON.stringify(myData) + "'")
         .then(function (response) { console.log(response.data); });

    $http.post(url, "'" + angular.toJson(myData) + "'")
         .then(function (response) { console.log(response.data); });

C#:

    public class NamedController : ApiController
    {
        [HttpPost]
        public int NamedMethod([FromBody] string value)
        {
            return value == null ? 1 : 0;
        }
    }

Tuve el mismo problema de obtener null como parámetro, pero estaba relacionado con objetos grandes. Resultó que el problema estaba relacionado con la longitud máxima de IIS. Se puede configurar en web.config.

  <system.web>
    <httpRuntime targetFramework="4.7" maxRequestLength="1073741824" />
  </system.web>

Me pregunto por qué Web API suprimió el error y envía objetos null a mis API. Encontré el error usando Microsoft.AspNet.WebAPI.Rastreo.

Llego bastante tarde a esto, pero estaba teniendo problemas similares y después de un día de pasar por muchas de las respuestas aquí y obtener antecedentes, he encontrado la solución más fácil/liviana para pasar uno o más parámetros a una Acción de Web API 2 es la siguiente:

Esto supone que sabe cómo configurar un controlador/acción de API web con enrutamiento correcto, si no se refiere a: https://docs.microsoft.com/en-us/aspnet/web-api/overview/getting-started-with-aspnet-web-api/tutorial-your-first-web-api.

Primero la Acción del Controlador, esta solución también requiere Newtonsoft.Biblioteca Json.

[HttpPost]
public string PostProcessData([FromBody]string parameters) {
    if (!String.IsNullOrEmpty(parameters)) {
        JObject json = JObject.Parse(parameters);

        // Code logic below
        // Can access params via json["paramName"].ToString();
    }
    return "";
}

Lado del cliente usando jQuery

var dataToSend = JSON.stringify({ param1: "value1", param2: "value2"...});
$.post('/Web_API_URI', { '': dataToSend }).done(function (data) {
     console.debug(data); // returned data from Web API
 });

El problema clave que encontré fue asegurarse de que solo envíe un solo parámetro general a la API Web y asegúrese de que no tenga nombre solo el valor { '': dataToSend } de lo contrario, su valor será nulo en el servidor lado.

Con esto puede enviar uno o varios parámetros a la Web API en una estructura JSON y no necesita declarar ningún objeto adicional del lado del servidor para manejar datos complejos. El proyecto de trabajo también le permite iterar dinámicamente sobre todos los parámetros pasados para permitir una escalabilidad más fácil si sus parámetros cambian con el tiempo. Espero que eso ayude a alguien que estaba luchando como yo.

Correcto pasar un solo parámetro en el cuerpo a WebAPI funciona este código $.post(url, { '': productId }

Y atraparlo en acción [HttpPost] public ShoppingCartAddRemoveViewModel Delete([FromBody]string value)

La clave es usar la palabra mágica 'valor'. Puede ser también int, o algún tipo primitivo. No importa el tipo de contenido o las correcciones de encabezado El desorden es que este código no funciona en la acción post de mvc.

El problema es que su método de acción espera un tipo simple, es decir, un valor de parámetro de cadena. Lo que estás proporcionando es un objeto.

Hay 2 soluciones a su problema.

1. Cree una clase simple con la propiedad" value "y luego use esa clase como parámetro, en cuyo caso Web API model binding leerá el objeto JSON de la solicitud y lo vinculará a su propiedad" values " del objeto param.

2. Simplemente pase el valor de la cadena "prueba", y funcionará.

Si pones una anotación [FromBody] y tienes un objeto Dto como parámetro en tu método y aún no puedes obtener los datos, comienza a buscar en las propiedades y campos de tu DTO.

Tuve este mismo problema, donde mi DTO venía null. Me pareció que la razón era que una de las propiedades estaba apuntando a un objeto que no puede ser serializado :( lo que hace que el formateador de medios no pueda analizar los datos. Así el objeto era siempre nulo. Espero que ayuda a otros también

Revise sus tipos de datos. El aglutinante del modelo dotnet no convertirá un flotador en un entero (y estoy asumiendo otros conceptos relacionados). Esto hará que todo el modelo sea rechazado.

Si tienes json como este:

{
    "shoeSize": 10.5
}

Pero su modelo de c# se ve así:

class Shoe{
    public int shoeSize;
}

El aglutinante del modelo rechazará el modelo y obtendrá null.