Parâmetros múltiplos de colocação / publicação de WebAPI

Estou tentando postar vários parâmetros em um controlador WebAPI. Um parâmetro é do URL e o outro do corpo. Aqui está o URL: /offers/40D5E19D-0CD5-4FBD-92F8-43FDBB475333/prices/

Aqui está o código do meu controlador:

public HttpResponseMessage Put(Guid offerId, OfferPriceParameters offerPriceParameters)
{
    //What!?
    var ser = new DataContractJsonSerializer(typeof(OfferPriceParameters));
    HttpContext.Current.Request.InputStream.Position = 0;
    var what = ser.ReadObject(HttpContext.Current.Request.InputStream);

    return new HttpResponseMessage(HttpStatusCode.Created);
}

O conteúdo do corpo está em JSON:

{
    "Associations":
    {
        "list": [
        {
            "FromEntityId":"276774bb-9bd9-4bbd-a7e7-6ed3d69f196f",
            "ToEntityId":"ed0d2616-f707-446b-9e40-b77b94fb7d2b",
            "Types":
            {
                "list":[
                {
                    "BillingCommitment":5,
                    "BillingCycle":5,
                    "Prices":
                    {
                        "list":[
                        {
                            "CurrencyId":"274d24c9-7d0b-40ea-a936-e800d74ead53",
                            "RecurringFee":4,
                            "SetupFee":5
                        }]
                    }
                }]
            }
        }]
    }
}

Alguma idéia de por que a ligação padrão não é capaz de se ligar ao offerPriceParametersargumento do meu controlador? É sempre definido como nulo. Mas eu sou capaz de recuperar os dados do corpo usando o DataContractJsonSerializer.

Também tento usar o FromBodyatributo do argumento, mas ele também não funciona.

[HttpPost]
public string MyMethod([FromBody]JObject data)
{
    Customer customer = data["customerData"].ToObject<Customer>();
    Product product = data["productData"].ToObject<Product>();
    Employee employee = data["employeeData"].ToObject<Employee>();
    //... other class....
}

usando referência

using Newtonsoft.Json.Linq;

Solicitação de uso para JQuery Ajax

var customer = {
    "Name": "jhon",
    "Id": 1,
};
var product = {
    "Name": "table",
    "CategoryId": 5,
    "Count": 100
};
var employee = {
    "Name": "Fatih",
    "Id": 4,
};

var myData = {};
myData.customerData = customer;
myData.productData = product;
myData.employeeData = employee;

$.ajax({
    type: 'POST',
    async: true,
    dataType: "json",
    url: "Your Url",
    data: myData,
    success: function (data) {
        console.log("Response Data ↓");
        console.log(data);
    },
    error: function (err) {
        console.log(err);
    }
});

O WebAPI nativamente não suporta a ligação de vários parâmetros POST. Como Colin aponta, há várias limitações descritas no meu post no blog que ele faz referência.

Existe uma solução alternativa ao criar um fichário de parâmetros personalizado. O código para fazer isso é feio e complicado, mas eu publiquei o código junto com uma explicação detalhada no meu blog, pronta para ser conectada a um projeto aqui:

Passando vários valores POST simples para a API da Web do ASP.NET

Se o roteamento de atributo estiver sendo usado, você poderá usar os atributos [FromUri] e [FromBody].

Exemplo:

[HttpPost()]
[Route("api/products/{id:int}")]
public HttpResponseMessage AddProduct([FromUri()] int id,  [FromBody()] Product product)
{
  // Add product
}

Passamos o objeto Json pelo método HttpPost e o analisamos no objeto dinâmico. Funciona bem. este é um código de exemplo:

webapi:

[HttpPost]
public string DoJson2(dynamic data)
{
   //whole:
   var c = JsonConvert.DeserializeObject<YourObjectTypeHere>(data.ToString()); 

   //or 
   var c1 = JsonConvert.DeserializeObject< ComplexObject1 >(data.c1.ToString());

   var c2 = JsonConvert.DeserializeObject< ComplexObject2 >(data.c2.ToString());

   string appName = data.AppName;
   int appInstanceID = data.AppInstanceID;
   string processGUID = data.ProcessGUID;
   int userID = data.UserID;
   string userName = data.UserName;
   var performer = JsonConvert.DeserializeObject< NextActivityPerformers >(data.NextActivityPerformers.ToString());

   ...
}

O tipo de objeto complexo pode ser objeto, matriz e dicionário.

ajaxPost:
...
Content-Type: application/json,
data: {"AppName":"SamplePrice",
       "AppInstanceID":"100",
       "ProcessGUID":"072af8c3-482a-4b1c‌​-890b-685ce2fcc75d",
       "UserID":"20",
       "UserName":"Jack",
       "NextActivityPerformers":{
           "39‌​c71004-d822-4c15-9ff2-94ca1068d745":[{
                 "UserID":10,
                 "UserName":"Smith"
           }]
       }}
...

Uma classe de parâmetro simples pode ser usada para passar vários parâmetros em uma postagem:

public class AddCustomerArgs
{
    public string First { get; set; }
    public string Last { get; set; }
}

[HttpPost]
public IHttpActionResult AddCustomer(AddCustomerArgs args)
{
    //use args...
    return Ok();
}

Você pode permitir vários parâmetros POST usando a classe MultiPostParameterBinding em https://github.com/keith5000/MultiPostParameterBinding

Para usá-lo:

1) Faça o download do código na pasta Origem e adicione-o ao seu projeto de API da Web ou a qualquer outro projeto na solução.

2) Use o atributo [MultiPostParameters] nos métodos de ação que precisam oferecer suporte a vários parâmetros do POST.

[MultiPostParameters]
public string DoSomething(CustomType param1, CustomType param2, string param3) { ... }

3) Adicione esta linha no Global.asax.cs ao método Application_Start em qualquer lugar antes da chamada para GlobalConfiguration.Configure (WebApiConfig.Register) :

GlobalConfiguration.Configuration.ParameterBindingRules.Insert(0, MultiPostParameterBinding.CreateBindingForMarkedParameters);

4) Faça com que seus clientes passem os parâmetros como propriedades de um objeto. Um exemplo de objeto JSON para o DoSomething(param1, param2, param3)método é:

{ param1:{ Text:"" }, param2:{ Text:"" }, param3:"" }

Exemplo de JQuery:

$.ajax({
    data: JSON.stringify({ param1:{ Text:"" }, param2:{ Text:"" }, param3:"" }),
    url: '/MyService/DoSomething',
    contentType: "application/json", method: "POST", processData: false
})
.success(function (result) { ... });

Visite o link para mais detalhes.

Isenção de responsabilidade: estou diretamente associado ao recurso vinculado.

Boa pergunta e comentários - aprendi muito com as respostas aqui :)

Como um exemplo adicional, observe que você também pode misturar corpo e rotas, por exemplo

[RoutePrefix("api/test")]
public class MyProtectedController 
{
    [Authorize]
    [Route("id/{id}")]
    public IEnumerable<object> Post(String id, [FromBody] JObject data)
    {
        /*
          id                                      = "123"
          data.GetValue("username").ToString()    = "user1"
          data.GetValue("password").ToString()    = "pass1"
         */
    }
}

Chamando assim:

POST /api/test/id/123 HTTP/1.1
Host: localhost
Accept: application/json
Content-Type: application/x-www-form-urlencoded
Authorization: Bearer x.y.z
Cache-Control: no-cache

username=user1&password=pass1


enter code here

Como é o seu routeTemplate para este caso?

Você postou este URL:

/offers/40D5E19D-0CD5-4FBD-92F8-43FDBB475333/prices/

Para que isso funcione, eu esperaria um roteamento como este no seu WebApiConfig:

routeTemplate: {controller}/{offerId}/prices/

Outras suposições são: - seu controlador é chamado OffersController. - o objeto JSON que você está passando no corpo da solicitação é do tipo OfferPriceParameters(não qualquer tipo derivado) - você não possui outros métodos no controlador que possam interferir nesse (se houver, tente comentá-los e ver o que acontece)

E, como Filip mencionou, ajudaria suas perguntas se você começasse a aceitar algumas respostas, pois 'taxa de aceitação de 0%' pode fazer as pessoas pensarem que estão perdendo tempo.

Se você não deseja seguir o caminho ModelBinding, pode usar DTOs para fazer isso por você. Por exemplo, crie uma ação POST no DataLayer que aceite um tipo complexo e envie dados do BusinessLayer. Você pode fazer isso no caso de UI-> chamada de API.

Aqui estão os exemplos de DTO. Designe um professor para um aluno e atribua vários papéis / assunto ao aluno.

public class StudentCurriculumDTO
 {
     public StudentTeacherMapping StudentTeacherMapping { get; set; }
     public List<Paper> Paper { get; set; }
 }    
public class StudentTeacherMapping
 {
     public Guid StudentID { get; set; }
     public Guid TeacherId { get; set; }
 }

public class Paper
 {
     public Guid PaperID { get; set; }
     public string Status { get; set; }
 }

Em seguida, a ação no DataLayer pode ser criada como:

[HttpPost]
[ActionName("MyActionName")]
public async Task<IHttpActionResult> InternalName(StudentCurriculumDTO studentData)
  {
     //Do whatever.... insert the data if nothing else!
  }

Para chamá-lo do BusinessLayer:

using (HttpResponseMessage response = await client.PostAsJsonAsync("myendpoint_MyActionName", dataof_StudentCurriculumDTO)
  {
     //Do whatever.... get response if nothing else!
  }

Agora isso ainda funcionará se eu quiser enviar dados de vários Alunos de uma só vez. Modifique MyActioncomo abaixo. Não há necessidade de escrever [FromBody], o WebAPI2 assume o tipo complexo [FromBody] por padrão.

public async Task<IHttpActionResult> InternalName(List<StudentCurriculumDTO> studentData)

e, ao chamá-lo, passe um List<StudentCurriculumDTO>dado.

using (HttpResponseMessage response = await client.PostAsJsonAsync("myendpoint_MyActionName", List<dataof_StudentCurriculumDTO>)

Solicitar parâmetros como

Código da API da Web seja como

public class OrderItemDetailsViewModel
{
    public Order order { get; set; }
    public ItemDetails[] itemDetails { get; set; }
}

public IHttpActionResult Post(OrderItemDetailsViewModel orderInfo)
{
    Order ord = orderInfo.order;
    var ordDetails = orderInfo.itemDetails;
    return Ok();
}

Você pode obter os dados do formulário como string:

    protected NameValueCollection GetFormData()
    {
        string root = HttpContext.Current.Server.MapPath("~/App_Data");
        var provider = new MultipartFormDataStreamProvider(root);

        Request.Content.ReadAsMultipartAsync(provider);

        return provider.FormData;
    }

    [HttpPost]
    public void test() 
    {
        var formData = GetFormData();
        var userId = formData["userId"];

        // todo json stuff
    }

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