Le paramètre post est toujours nul
Depuis la mise à niveau vers RC pour WebAPI, je rencontre un problème vraiment étrange lorsque j'appelle POST sur mon WebAPI . Je suis même revenu à la version de base générée pour le nouveau projet. Alors:
public void Post(string value)
{
}
et appelant de Fiddler:
Header:
User-Agent: Fiddler
Host: localhost:60725
Content-Type: application/json
Content-Length: 29
Body:
{
"value": "test"
}
Lorsque je débogue, la chaîne "valeur" n'est jamais affectée. C'est juste toujours NUL… .. Toute personne ayant ce problème?
(J'ai d'abord vu le problème avec un type plus complexe)
Le problème n’est pas seulement lié à ASP.NET MVC 4, le même problème se produit pour un nouveau projet ASP.NET MVC 3 après l’installation de RC.
Comme vous n’avez qu’un seul paramètre, vous pouvez essayer de le décorer avec l’attribut [FromBody] ou modifier la méthode pour accepter un DTO avec une valeur en tant que propriété, comme je l’ai suggéré ici: MVC4 RC paramètre WebApi binding
MISE À JOUR: Le site officiel ASP.NET a été mis à jour aujourd'hui avec une excellente explication: http://www.asp.net/web-api/overview/working-with-http/sending-html-form-data,-part -1
En résumé, lorsque vous envoyez un seul type simple dans le corps, envoyez simplement la valeur précédée du signe égal (=), par ex. corps:
=test
Je me gratte la tête à ce sujet aujourd'hui.
Ma solution est de changer le [FromBody] en HttpRequestMessage, en déplaçant essentiellement la pile HTTP.
Dans mon cas, j'envoie des données sur le réseau qui est compressé JSON qui est ensuite en base64'd. Tout cela depuis une application Android.
La signature originale de mon point de terminaison Web ressemblait à ceci (en utilisant [FromBody]):
Mon correctif pour ce problème était de revenir à l'utilisation d'une HttpRequestMessage pour la signature de mon point de terminaison.
Vous pouvez ensuite accéder aux données de la publication en utilisant cette ligne de code:
Cela fonctionne et vous permet d'accéder aux données de publication brutes non modifiées. Vous n'êtes pas obligé de jouer avec le violoneur en mettant un signe = au début de votre chaîne ou en changeant le type de contenu.
En passant, j'ai d'abord essayé de suivre l'une des réponses ci-dessus, qui consistait à changer le type de contenu en: "Content-Type: application/x-www-form-urlencoded". Pour les données brutes, c'est un mauvais conseil car il supprime les caractères.
Donc, une chaîne base64 qui commence comme ceci: "MQ0AAB + LCAAAAAA" se termine comme ceci "MQ0AAB LCAAAAAA"! Pas ce que tu veux.
L'utilisation de HttpRequestMessage présente un autre avantage, à savoir que vous avez accès à tous les en-têtes http à partir de votre terminal.
Je viens d'avoir ce problème avec Fiddler. Le problème était que je n'avais pas spécifié Content-Type.
Essayez d’inclure un en-tête pour Content-Type dans votre demande POST.
Content-Type: application/x-www-form-urlencoded
Selon les commentaires ci-dessous, vous devrez peut-être également inclure un en-tête JSON.
Content-Type: application/json
J'ai rencontré ce problème aussi, et voici comment j'ai résolu mon problème
code webapi:
public void Post([FromBody] dynamic data)
{
string value = data.value;
/* do stuff */
}
code client:
$.post( "webapi/address", { value: "some value" } );
J'utilisais Postman et je faisais la même erreur .. en passant le value comme objet json au lieu de chaîne
{
"value": "test"
}
Clairement, celui-ci estincorrectlorsque le paramètre api est de type chaîne.
Donc, il suffit de passer la chaîne entre guillemets dans le corps de l’API:
"test"
Essayez de créer une classe qui servira de modèle de données, puis envoyez un objet JSON avec des propriétés correspondant à celles de votre classe de modèle de données. (Remarque: j'ai testé cela et cela fonctionne avec le dernier MVC 4 RC 2012 que je viens de télécharger aujourd'hui).
public HttpResponseMessage Post(ValueModel model)
{
return Request.CreateResponse<string>(HttpStatusCode.OK, "Value Recieved: " + model.Value);
}
public class ValueModel
{
public string Value { get; set; }
}
L'objet JSON ci-dessous est envoyé dans le corps HTTP-POST, le type de contenu est 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" }
Je crois que la raison pour laquelle vous devez créer une classe de modèle de données est que les valeurs simples sont supposées provenir des paramètres url et qu'une valeur complexe unique est supposée provenir du corps. Ils ont les attributs [FromBody] et [FromUrl], mais utiliser [FromBody] string value ne fonctionnait toujours pas pour moi. On dirait qu'ils travaillent encore beaucoup de bugs, alors je suis sûr que cela changera à l'avenir.
Edit: XML doit fonctionner dans le corps. Le sérialiseur XML par défaut a été remplacé par DataContractSerializer au lieu de XmlSerializer. Mettre la ligne suivante dans mon fichier Global.asax a résolu ce problème ( référence )
GlobalConfiguration.Configuration.Formatters.XmlFormatter.UseXmlSerializer = true;
Après quelques tentatives, je pense que le comportement par défaut est correct et qu'il n'y a rien à pirater.
Le seul truc est le suivant: si votre argument de méthode post est string comme ci-dessous, vous devez envoyer une chaîne simple avec des guillemets doubles dans le corps (lors de l’utilisation de ajax ou postman), par exemple,
//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}"
}
Sinon, si vous envoyez une chaîne json dans le corps du message sans les guillemets extérieurs et les guillemets intérieurs échappés, elle devrait pouvoir être analysée avec la classe de modèle (le type d'argument), par exemple, {"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"
}
Je cherchais une solution à ce problème depuis quelques minutes maintenant, je vais donc partager ma solution.
Si vous publiez un modèle, votre modèle doit avoir un constructeur vide/par défaut, sinon le modèle ne peut pas être créé, bien entendu . Soyez prudent lors du refactoring. ;)
Cela a fonctionné pour moi:
Créez une classe DTO C #, avec une propriété pour chaque attribut que vous souhaitez transmettre à partir de jQuery/Ajax
public class EntityData { public string Attr1 { get; set; } public string Attr2 { get; set; } }Définissez la méthode API Web:
[HttpPost()] public JObject AddNewEntity([FromBody] EntityData entityData) {Appelez l’API Web en tant que telle:
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) { ... } });
J'ai eu le même problème et j'ai constaté que le changement du type de contenu en "application/json" ne résolvait pas le problème. Cependant, "application/json; charset = utf-8" a fonctionné.
J'ai eu un problème similaire où l'objet de requête pour ma méthode API Web était toujours null. J'ai remarqué que puisque le nom d'action du contrôleur était préfixé par "Get", Web API l'a traité comme un HTTP GET plutôt qu'un POST. Après avoir renommé l'action du contrôleur, il fonctionne maintenant comme prévu.
Pour ceux qui ont le même problème avec Swagger ou Postman comme je l'ai fait, si vous transmettez un attribut simple sous forme de chaîne dans un message, même avec le "ContentType" spécifié, vous continuerez à obtenir une valeur nulle.
En passant juste:
MyValue
Va entrer dans le contrôleur en tant que null.
Mais si vous passez:
"MyValue"
La valeur ira bien.
Les citations ont fait la différence ici. Bien sûr, cela ne concerne que Swagger et Postman. Par exemple, dans une application Frontend utilisant Angular, ceci devrait être résolu automatiquement par le framework.
Dans mon cas, le problème était que le paramètre était une chaîne et non un objet, j'ai changé le paramètre pour qu'il soit JObject of Newsoft.Json et cela fonctionne.
Si vous êtes sûr de votre JSON envoyé, vous devez suivre votre API avec soin:
- Installer le package
Microsoft.AspNet.WebApi.Tracing - Ajoutez
config.EnableSystemDiagnosticsTracing();dans la classeWebApiConfigdans la méthodeRegister.
Examinez maintenant le résultat du débogage et vous trouverez probablement une entrée de journal non valide ModelState.
Si ModelState est invalide, vous pouvez trouver la cause réelle dans sa Errors:
Personne ne peut même deviner une telle exception:
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)
Si vous utilisez un DataContractSerializer pour votre formateur Xml ou votre formateur JSON, vous devez vous en débarrasser.
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;
}
Je commente simplement jsonFormatter.UseDataContractJsonSerializer = true; et mon paramètre d'entrée n'est plus nul. Merci à "Despertar" de me donner un indice.
Ajout de ligne
ValueProviderFactories.Factories.Add(new JsonValueProviderFactory());
jusqu'à la fin de la fonction protected void Application_Start() dans Global.asax.cs a résolu un problème similaire pour moi dans ASP.NET MVC3.
Avec Angular, j'ai pu transmettre des données dans ce format:
data: '=' + JSON.stringify({ u: $scope.usrname1, p: $scope.pwd1 }),
headers: { 'Content-Type': 'application/x-www-form-urlencoded; charset=utf-8' }
Et dans le contrôleur 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"];
......
Alternativement, je pourrais aussi publier des données JSON comme ceci:
data: { PaintingId: 1, Title: "Animal show", Price: 10.50 }
Et, dans le contrôleur, acceptez un type de classe comme celui-ci:
[HttpPost]
public string POST(Models.PostModel pm)
{
....
}
Dans les deux cas, si vous avez une classe publique établie dans l'API, postez JSON, sinon postez = = + JSON.stringify ({..: ..., ..: ...})
Je suis un peu en retard pour la fête, mais quiconque tombe sur une valeur NULL transmise lors de l'utilisation d'un contrôleur ajoute simplement "=" au début de votre demande POST.
Le contrôleur a également transmis une valeur NULL lorsque j'ai utilisé le type de contenu application/json. Notez le type de contenu "application/x-www-form-urlencoded" ci-dessous. Le type de retour de l'API est cependant "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;
}
La meilleure solution pour moi consiste à utiliser le protocole HTTP complet comme indiqué ci-dessous:
[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;
}
puis en désérialisant la chaîne sur l'objet que vous attendez dans le corps du message . Pour moi, WS_OpenSession est une classe contenant les identificateurs sessionid, user et key.
Vous pouvez à partir de là utiliser l'objet param et accéder à ses propriétés.
Très très efficace.
J'ai dit provenant de cette URL:
J'ai eu le même problème d'obtention de null en tant que paramètre, mais c'était lié à des objets volumineux. Il s’est avéré que le problème était lié à IIS longueur maximale. Il peut être configuré dans web.config.
<system.web>
<httpRuntime targetFramework="4.7" maxRequestLength="1073741824" />
</system.web>
Je me demande pourquoi l'API Web a supprimé l'erreur et envoyé des objets nuls à mes API. J'ai trouvé l'erreur en utilisant Microsoft.AspNet.WebApi.Tracing.
Je sais que ce n'est pas une réponse à cette question, mais je l'ai trouvée en cherchant une solution à mon problème.
Dans mon cas, le type complexe n'était pas lié mais je ne faisais pas de POST, je faisais un GET avec des paramètres de chaîne de requête. La solution consistait à ajouter [FromUri] à l'argument:
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
}
}
Je suis assez en retard, mais je rencontrais des problèmes similaires. Après une journée de recherches approfondies et de recherches de fond, j’ai trouvé la solution la plus simple et la plus simple pour renvoyer un ou plusieurs paramètres à une API Web. suit:
Cela suppose que vous sachiez comment configurer une action/contrôleur API Web avec un routage correct, si vous ne vous référez pas à: https://docs.Microsoft.com/en-us/aspnet/web-api/overview/getting-started -with-aspnet-web-api/tutoriel-votre-première-web-api .
Tout d'abord l'action du contrôleur, cette solution nécessite également la bibliothèque 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 "";
}
Côté client utilisant 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
});
Le problème clé que j’ai trouvé était de s’assurer que vous n’envoyiez qu’un seul paramètre global à l’API Web et qu’il n’avait pas de nom mais uniquement la valeur { '': dataToSend }autrement, votre valeur serait nulle du côté serveur.
Grâce à cela, vous pouvez envoyer un ou plusieurs paramètres à l'API Web dans une structure JSON. Il n'est pas nécessaire de déclarer des objets supplémentaires côté serveur pour gérer des données complexes. Le JObject vous permet également de parcourir de manière dynamique tous les paramètres passés, ce qui permet une évolutivité plus facile si vos paramètres changent avec le temps. Espérons que cela aide quelqu'un qui se débattait comme moi.
Pour les types complexes, Web API tente de lire la valeur dans le corps du message à l'aide d'un outil de formatage de type média.
Vérifiez si vous avez un attribut [Serializable] décorant votre classe de modèle.
Supprimez l'attribut pour voir si cela fonctionne. Cela a fonctionné pour moi.
Le moyen le plus simple que j'ai trouvé pour traiter un objet JSON simple que je passe dans MVC 6 consiste à obtenir le type du paramètre post comme NewtonSoft jObject:
public ActionResult Test2([FromBody] jObject str)
{
return Json(new { message = "Test1 Returned: "+ str }); ;
}
J'ai eu le même problème dans Fiddler. J'ai déjà eu Content-Type: application/json; charset=utf-8 ou Content-Type: application/json dans l'en-tête de la demande.
Le corps de ma requête était également une chaîne simple et dans Fiddler, j'avais écrit: {'controller':'ctrl'}. Cela a fait que le paramètre de chaîne de ma méthode POST soit null.
Fix : n'oubliez pas d'utiliser des guillemets, indiquant ainsi une chaîne. C'est-à-dire que je l'ai corrigé en écrivant "{'controller':'ctrl'}". (Remarque: lors de l'écriture de JSON, veillez à utiliser des apostrophes ou échappez aux guillemets comme ceci: "{\"controller\":\"ctrl\"}").
peu importe le type de valeur que vous souhaitez publier, placez-la simplement entre guillemets pour l'obtenir sous forme de chaîne. Pas pour les types complexes.
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;
}
}
Si vous avez ce caractère '\' dans votre requête json dans Postman, vous devez l'échapper si vous avez besoin du caractère '\' dans la valeur de la chaîne json.
Exemple:
{
"path": "C:\\Users\\Test\\Documents\\test.txt"
}
Le passage correct du paramètre unique dans le corps à WebAPI fonctionne avec ce code $.post(url, { '': productId }
Et le rattraper en action [HttpPost] public ShoppingCartAddRemoveViewModel Delete([FromBody]string value)
La clé est d'utiliser la «valeur» magique de Word. Ce peut être aussi int, ou un type primitif . Peu importe le type de contenu ou les corrections d’en-tête.
Dans mon cas, décorer la classe de paramètres avec l’attribut [JsonObject(MemberSerialization.OptOut)] de Newtonsoft a été efficace.
Par exemple:
[HttpPost]
[Route("MyRoute")]
public IHttpActionResult DoWork(MyClass args)
{
...
}
[JsonObject(MemberSerialization.OptOut)]
public Class MyClass
{
...
}
JSON.stringify (...) a résolu mes problèmes
API:
[HttpPost]
public bool UpdateTicketStatus(Ticket t)
{
string Id=t.Id;
}
Modèle:
public class Ticket
{
public int Id { get; set; }
public string AssignedTo { get; set; }
public string State { get; set; }
public string History { get; set; }
}
À l'aide de l'outil Postman, envoyez le contenu au format json avec les données brutes ci-dessous. Ça marche
{"Id": "169248", "AssignedTo": "xxxx", "State": "Committed", "History": "test1"}
Assurez-vous d'avoir activé Cors.
[EnableCors(origins: "*", headers: "*", methods: "*")]
public class TicketController : ApiController
{
}
Vérifiez vos types de données. Le classeur de modèles dotnet ne convertira pas un float en entier (et je suppose d’autres concepts connexes). Cela entraînera le rejet de tout le modèle.
Si vous avez json comme ça:
{
"shoeSize": 10.5
}
mais votre modèle c # ressemble à ceci:
class Shoe{
public int shoeSize;
}
le classeur de modèle rejettera le modèle et vous obtiendrez null.
Un problème similaire rencontré dans ASP.NET Core a été rencontré et une autre cause possible est un échec de liaison ASP.NET (silencieux) dû à diverses raisons, telles que l'envoi de null à lié à une propriété non nulle}:
{
"prop1":1139357,
"prop2":1139356,
"items":[
{"key":"15","someprop":34,"notnullprop":null},
{"key":"16","someprop":34,"notnullprop":null},
{"key":"22","someprop":34,"notnullprop":null}]
}
Dans ce cas, il y a aucune exception n'est générée et le modèle entier sera nul}, même si cela se produit au plus profond de la hiérarchie des objets.
J'espère que cela t'aides.
En regardant dans différents commentaires et autres forums, je mélange des extraits et pour moi, ce code fonctionne ...
... dans le contrôleur
public HttpResponseMessage Post([FromBody] string jsonData)
{
HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.OK, jsonData);
try
{
string jsonString = jsonData.ToString();
JArray jsonVal = JArray.Parse(jsonString) as JArray;
dynamic mylist= jsonVal;
foreach (dynamic myitem in mylist)
{
string strClave=string.Empty;
string strNum=string.Empty;
string strStatus=string.Empty;
strClave = myitem.clave;
strNum=myitem.num;
strStatus = myitem.status;
}
... dans WebApiConfig.cs, incluez cette ligne pour éviter la valeur null dans la variable [FromBody] var jsonFormatter = config.Formatters.OfType (). First ();
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(); /*this line makes no more null when use [FromBody]*/
}
.... Du côté client, le plus important est de concaténer le signe égal avant les données sérialisées (string json = "=" + SerialData;)
pour sérialiser j'utilise
System.Web.Script.Serialization.JavaScriptSerializer serializer = new
System.Web.Script.Serialization.JavaScriptSerializer();
List<Dictionary<string, object>> rows = new List<Dictionary<string, object>>();
Dictionary<string, object> row;
foreach (DataRow dr in DsCnx.Tables[0].Rows)
{
row = new Dictionary<string, object>();
foreach (DataColumn col in DsCnx.Tables[0].Columns)
{
row.Add(col.ColumnName, dr[col]);
}
rows.Add(row);
}
SerialData= serializer.Serialize(rows);
PostRequest("http://localhost:53922/api/Demo", SerialData);
c'est ma fonction PostRequest, ici le type de contenu que j'utilise est httpWebRequest.ContentType = "application/x-www-form-urlencoded; charset = utf-8";:
private static string PostRequest(string url, string SerialData)
{
string result = String.Empty;
HttpWebRequest httpWebRequest = (HttpWebRequest)WebRequest.Create(url);
httpWebRequest.ContentType = "application/x-www-form-urlencoded; charset=utf-8";
httpWebRequest.Method = "POST";
using (var streamWriter = new StreamWriter(httpWebRequest.GetRequestStream()))
{
string json = "=" + SerialData;
streamWriter.Write(json);
streamWriter.Flush();
streamWriter.Close();
}
try
{
using (var response = httpWebRequest.GetResponse() as HttpWebResponse)
{
if (httpWebRequest.HaveResponse && response != null)
{
using (var reader = new StreamReader(response.GetResponseStream()))
{
result = reader.ReadToEnd();
}
}
}
}
catch (WebException e)
{
if (e.Response != null)
{
using (var errorResponse = (HttpWebResponse)e.Response)
{
using (var reader = new StreamReader(errorResponse.GetResponseStream()))
{
string error = reader.ReadToEnd();
result = error;
}
}
}
}
return result.ToString();
}
voici les liens où j'ai trouvé un exemple de code pour référence:
https://blog.codenamed.nl/2015/05/12/why-your-frombody-parameter-is-always-null/
Si vous mettez une annotation [FromBody] et que vous avez un objet Dto en tant que paramètre de votre méthode et que vous ne pouvez toujours pas obtenir les données, commencez à examiner les propriétés et les champs de votre DTO.
J'ai eu ce même problème, où mon DTO devenait nul. J'ai découvert que la raison était que l'une des propriétés pointait vers un objetqui ne peut pas être sérialisé:(, ce qui empêche le formateur de média d'analyser les données. Ainsi, l'objet était toujours nul J'espère que ça aidera les autres aussi
Le problème est que votre méthode d’action attend un type simple, c’est-à-dire une valeur de paramètre de chaîne. Ce que vous fournissez est un objet.
Il y a 2 solutions à votre problème.
Créez une classe simple avec la propriété "value ", puis utilisez cette classe en tant que paramètre. Dans ce cas, la liaison de modèle d'API Web lira l'objet JSON de request et le liera à votre propriété "values".
Il suffit de passer la valeur de chaîne " test ", et cela fonctionnera.