Il parametro Post è sempre nullo

Da quando ho effettuato l'aggiornamento a RC per WebAPI, ho riscontrato dei problemi davvero strani quando ho chiamato POST sul mio WebAPI. Sono anche tornato alla versione base generata sul nuovo progetto. Così:

public void Post(string value)
{
}

e chiamando da Fiddler:

Header:
User-Agent: Fiddler
Host: localhost:60725
Content-Type: application/json
Content-Length: 29

Body:
{
    "value": "test"
}

Quando eseguo il debug, la stringa "valore" non viene mai assegnata. È sempre sempre NULL. Qualcuno ha questo problema?

(Ho visto per la prima volta il problema con un tipo più complesso)

Il problema non è legato solo ad ASP.NET MVC 4, lo stesso problema si verifica per un nuovo progetto ASP.NET MVC 3 dopo l'installazione RC

Dato che hai solo un parametro, puoi provare a decorarlo con l' [FromBody]attributo o cambiare il metodo per accettare un DTO con valore come proprietà, come ho suggerito qui: MVC4 RC WebApi binding dei parametri

AGGIORNAMENTO: il sito ASP.NET ufficiale è stato aggiornato oggi con un'ottima spiegazione: https://docs.microsoft.com/en-us/aspnet/web-api/overview/advanced/sending-html-form-data-part- 1

In breve, quando si invia un singolo tipo semplice nel corpo, inviare solo il valore con il segno di uguale (=), ad esempio corpo:

=test

Oggi mi sto grattando la testa.

La mia soluzione è quella di cambiare [FromBody]in a HttpRequestMessage, essenzialmente spostando lo stack HTTP.

Nel mio caso sto inviando dati attraverso il filo che è zippato json che è quindi base64. Tutto questo da un'app Android.

La firma originale del mio endpoint Web era simile a questa (utilizzando [FromBody]):

La mia correzione per questo problema è stata quella di ripristinare l'utilizzo di a HttpRequestMessageper la firma del mio endpoint.

È quindi possibile ottenere l'accesso ai dati di post utilizzando questa riga di codice:

Funziona e ti consente di accedere ai dati grezzi non trattati dei post. Non devi scherzare con il violinista mettendo un segno = all'inizio della stringa o modificando il tipo di contenuto.

Per inciso, ho prima provato a seguire una delle risposte sopra che era di cambiare il tipo di contenuto in: "Content-Type: application / x-www-form-urlencoded". Per i dati non elaborati questo è un cattivo consiglio perché rimuove + caratteri.

Quindi una stringa base64 che inizia così: "MQ0AAB + LCAAAAAA" finisce così "MQ0AAB LCAAAAAA"! Non quello che vuoi

Un altro vantaggio dell'utilizzo HttpRequestMessageè che si ottiene l'accesso a tutte le intestazioni http dall'endpoint.

Ho appena avuto questo accadere usando Fiddler. Il problema era che non avevo specificato Content-Type.

Prova a includere un'intestazione Content-Typenella tua richiesta POST.

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

In alternativa, come da commenti di seguito, potrebbe essere necessario includere un'intestazione JSON

Content-Type: application/json

Ho riscontrato anche questo problema, ed è così che ho risolto il mio problema

codice webapi:

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

codice cliente:

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

Stavo usando Postmane stavo facendo lo stesso errore .. passando l' valueoggetto as json invece di stringa

{
    "value": "test"
}

Chiaramente quello sopra è sbagliato quando il parametro api è di tipo stringa.

Quindi, basta passare la stringa tra virgolette doppie nel corpo dell'API:

"test"

Prova a creare una classe da utilizzare come modello di dati, quindi invia un oggetto JSON con proprietà corrispondenti alle proprietà della classe del modello di dati. (Nota: l'ho provato e funziona con l'ultimo MVC 4 RC 2012 che ho appena scaricato oggi).

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

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

L'oggetto JSON sottostante viene inviato nel corpo HTTP-POST, il tipo di contenuto è 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" }

Credo che il motivo per cui devi creare una classe del modello di dati sia perché si presume che i valori semplici provengano dai parametri url e che un singolo valore complesso sia assunto dal corpo. Hanno gli attributi [FromBody]e [FromUrl], ma l'utilizzo [FromBody] string valuenon ha funzionato per me. Sembra che stiano ancora risolvendo molti bug, quindi sono sicuro che questo cambierà in futuro.

Modifica: XML ha funzionato nel corpo. Il serializzatore XML predefinito è stato modificato in DataContractSerializer anziché in XmlSerializer. Mettere la seguente riga nel mio file Global.asax ha risolto questo problema ( riferimento )

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

Dopo alcuni tentativi, penso che il comportamento predefinito sia corretto e non c'è nulla da hackerare.

L'unico trucco è: se l'argomento del tuo metodo post è stringcome sotto, dovresti inviare una stringa semplice con doppie virgolette nel corpo (quando usi ajax o postman), ad es.

//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}"
}

Altrimenti se invii una stringa json nel corpo del post senza virgolette doppie esterne e virgolette interne sfuggite, allora dovrebbe essere in grado di essere analizzato nella classe del modello (il tipo di argomento), ad es.{"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"
}

Da qualche minuto cercavo una soluzione a questo problema, quindi condividerò la mia soluzione.

Se pubblichi un modello, il tuo modello deve avere un costruttore vuoto / predefinito, altrimenti il ​​modello non può essere creato, ovviamente. Fai attenzione durante il refactoring. ;)

Questo ha funzionato per me:

1. Creare una classe DTO C #, con una proprietà per ogni attributo che si desidera passare da jQuery / Ajax

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

2. Definire il metodo API Web:

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

3. Chiama l'API Web come tale:

   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) {
           ...
       }
   });

Per coloro che hanno lo stesso problema con Swagger o Postman come ho fatto io, se si passa un attributo semplice come stringa in un post, anche con "ContentType" specificato, si otterrà comunque un valore nullo.

Passando solo:

MyValue

Entrerà nel controller come null.

Ma se passi:

"MyValue"

Il valore sarà corretto.

Le virgolette hanno fatto la differenza qui. Naturalmente, questo è solo per Swagger e Postman. Ad esempio, in un'app Frontend che utilizza Angular questo dovrebbe essere risolto automaticamente dal framework.

Ho avuto lo stesso problema e ho scoperto che quando si cambia il tipo di contenuto in "application / json" non è stato risolto il problema. Tuttavia "application / json; charset = utf-8" ha funzionato.

Ho avuto un problema simile in cui l'oggetto richiesta per il mio metodo API Web era sempre nullo. Ho notato che poiché il nome dell'azione del controller era preceduto da "Get", l'API Web ha trattato questo come un HTTP GET anziché un POST. Dopo aver rinominato l'azione del controller, ora funziona come previsto.

Con Angular, sono stato in grado di trasmettere i dati in questo formato:

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

E in Controllo API Web:

    [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"];
   ......

In alternativa, potrei anche pubblicare dati JSON in questo modo:

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

E, nel controller, accetta un tipo di classe come questo:

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

     ....
    }

In ogni caso, se hai una classe pubblica stabilita nell'API, pubblica JSON, altrimenti pubblica '=' + JSON.stringify ({..: ..., ..: ...})

Nel mio caso il problema era che il parametro era una stringa e non un oggetto, ho cambiato il parametro in JObject di Newsoft.Json e funziona.

Aggiunta di una riga

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

fino alla fine della funzione protected void Application_Start()in Global.asax.cs risolto problema simile per me in ASP.NET MVC3.

Se stai usando un DataContractSerializer per il tuo Xml Formatter o JSON Formatter, devi sbarazzartene. Ho avuto questo nel mio file 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;
}

Semplicemente commento jsonFormatter.UseDataContractJsonSerializer = true;e il mio parametro di input non è più nullo. Grazie a "Despertar" per avermi dato un indizio.

Se sei sicuro del tuo JSON inviato, devi tracciare attentamente l'API:

1. Installare Microsoft.AspNet.WebApi.Tracing pacchetto
2. Aggiungi config.EnableSystemDiagnosticsTracing();il metodo WebApiConfigclass inside Register.

Ora guarda l'output di Debug e probabilmente troverai un non valido ModelState voce di registro .

Se ModelStatenon è valido, potresti trovare la vera causa nel suo Errors:

Nessuno può nemmeno immaginare un'eccezione del genere:

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)

Ho avuto lo stesso problema di ottenere null come parametro, ma era correlato a oggetti di grandi dimensioni. Si è scoperto che il problema era legato alla lunghezza massima di IIS. Può essere configurato in web.config.

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

Mi chiedo perché l'API Web abbia eliminato l'errore e invii oggetti null alle mie API. Ho trovato l'errore utilizzando Microsoft.AspNet.WebApi.Tracing.

JSON.stringify (...) ha risolto i miei problemi

So che questa non è una risposta a questa domanda, ma mi sono imbattuto durante la ricerca di una soluzione al mio problema.

Nel mio caso, il tipo complesso non era associato ma non stavo facendo un POST, stavo facendo un GET con parametri di querystring. La soluzione era aggiungere [FromUri] all'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
    }
}

Ho avuto lo stesso problema in Fiddler. Ho già avuto Content-Type: application/json; charset=utf-8o Content-Type: application/jsonnell'intestazione della richiesta.

Il mio corpo era richiesta anche una stringa pianura, e in Fiddler mi aveva scritto: {'controller':'ctrl'}. Ciò ha reso il parametro stringa nel mio metodo POST essere null.

Correzione : ricordarsi di usare le virgolette, indicando così una stringa. Cioè, l'ho risolto scrivendo "{'controller':'ctrl'}". (Nota: quando si scrive JSON, assicurarsi di usare gli apostrofi o di sfuggire alle virgolette in questo modo:) "{\"controller\":\"ctrl\"}".

Il modo più semplice che ho trovato per gestire un semplice oggetto JSON che passo in MVC 6 è ottenere il tipo di parametro post come NewtonSoft jObject:

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

La migliore soluzione per me sta diventando HTTP completo come di seguito:

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

e quindi deserializzare la stringa sull'oggetto che ti aspetti nel corpo del post. Per me, WS_OpenSession è una classe che conteneva sessionid, utente e chiave.

Da lì puoi usare l'oggetto param e accedere alle sue proprietà.

Molto molto efficace.

Ho detto proveniente da questo URL:

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

Per tipi complessi, l'API Web tenta di leggere il valore dal corpo del messaggio, utilizzando un formattatore di tipo multimediale.

Controlla se ne hai [Serializable] attributo che decora la tua classe di modello.

Rimuovi l'attributo per vedere se funziona. Questo ha funzionato per me.

Sono un po 'in ritardo alla festa, ma chiunque si imbatte in un valore NULL passato quando si utilizza un controller aggiunge semplicemente "=" all'inizio della richiesta POST.

Il controller ha anche passato un valore NULL quando ho usato l' applicazione / json Content-Type. Nota di seguito il tipo di contenuto "application / x-www-form-urlencoded". Il tipo restituito dall'API è tuttavia "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;
    }

non importa quale tipo di valore desideri pubblicare, racchiudilo tra virgolette per ottenerlo come stringa. Non per tipi complessi.

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

Se inserisci l'annotazione [FromBody] e hai un oggetto Dto come parametro nel tuo metodo e non riesci ancora a ottenere i dati, inizia a esaminare le proprietà e i campi del tuo DTO.

Ho avuto lo stesso problema, in cui il mio DTO stava diventando nullo. Ho scoperto che la ragione era che una delle proprietà puntava a un oggetto che non può essere serializzato :( che fa sì che il media-formatter non riesca a analizzare i dati. Quindi l'oggetto è sempre nullo. Spero che aiuti anche gli altri

Controlla nuovamente i tipi di dati. Il raccoglitore del modello dotnet non converte un float in un numero intero (e presumo altri concetti correlati). Ciò causerà il rifiuto dell'intero modello.

Se hai JSON in questo modo:

{
    "shoeSize": 10.5
}

ma il tuo modello c # è simile al seguente:

class Shoe{
    public int shoeSize;
}

il raccoglitore del modello rifiuterà il modello e otterrai null.

Sono piuttosto in ritardo, ma ho riscontrato problemi simili e dopo una giornata passata a leggere molte risposte qui e ottenendo un background, ho trovato la soluzione più semplice / leggera per restituire uno o più parametri a un'API Web 2 L'azione è come segue:

Ciò presuppone che tu sappia come impostare un controller / azione API Web con il routing corretto, se non fai riferimento a: https://docs.microsoft.com/en-us/aspnet/web-api/overview/getting-started-with -aspnet-web-api / dimostrativi-your-prima-web-api .

Innanzitutto l'azione del controller, questa soluzione richiede anche la libreria Newtonsoft.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 "";
}

Lato client utilizzando 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
 });

Il problema chiave che ho riscontrato è stato assicurarti di inviare di nuovo un singolo parametro generale all'API Web e assicurarti che non abbia un nome, ma solo il valore, { '': dataToSend }altrimenti il ​​tuo valore sarà nullo sul lato server.

Con questo è possibile inviare uno o più parametri all'API Web in una struttura JSON e non è necessario dichiarare alcun oggetto aggiuntivo lato server per gestire dati complessi. JObject consente inoltre di scorrere dinamicamente tutti i parametri passati per consentire una più facile scalabilità nel caso in cui i parametri cambino nel tempo. Spero che questo aiuti qualcuno che sta lottando come me.

Il corretto passaggio del singolo parametro nel corpo a WebAPI funziona con questo codice $.post(url, { '': productId }

E prenderlo in azione [HttpPost] public ShoppingCartAddRemoveViewModel Delete([FromBody]string value)

La chiave è usare la parola magica "valore". Può anche essere int o un tipo primitivo. Indipendentemente dal tipo di contenuto o dalle correzioni dell'intestazione, il disordine è che questo codice non funziona in post azione mvc.