Come devo passare più parametri a un ASP.Net Web API GET?

Sto usando l'API Web .Net MVC4 per (si spera) implementare un API RESTful. Devo passare alcuni parametri al sistema e farlo eseguire alcune azioni, quindi restituire un elenco di oggetti come risultati. In particolare, sto passando in due date e restituendo i record che cadono tra di loro. Sto anche tenendo traccia dei record restituiti in modo che le chiamate successive non vengano rielaborate nel sistema.

Ho preso in considerazione alcuni approcci:

1. Serializzare i parametri in un'unica stringa JSON e selezionarli nell'API. http://forums.asp.net/t/1807316.aspx/1

2. Passa i parametri nella stringa di query.
   Qual è il modo migliore per passare più parametri di query a un API riposante?

3. Definizione dei parametri nel percorso: api / controller / date1 / date2

4. Utilizzo di un POST che intrinsecamente mi consente di passare un oggetto con parametri.

5. Ricerca ODATA poiché l'API Web (attualmente) la supporta. Non ho ancora fatto molto con questo, quindi non ne ho molta familiarità.

Sembra che le pratiche REST appropriate indicano quando i dati vengono estratti, è necessario utilizzare un GET. Tuttavia, GET dovrebbe anche essere nullipotent (non produce effetti collaterali) e mi chiedo se la mia implementazione specifica violi dal momento che segnare i record nel sistema API, quindi sto producendo effetti collaterali.

Mi ha anche portato alla questione del supporto di parametri variabili. Se l'elenco dei parametri di input cambia, sarebbe noioso dover ridefinire il percorso per Choice 3 se ciò accade molto. E cosa potrebbe accadere se i parametri fossero definiti in fase di esecuzione ...

In ogni caso, per la mia specifica implementazione, quale scelta (se presente) sembra la migliore?

Cosa significa questo segno di registrazione? Se questo viene utilizzato solo a fini di registrazione, utilizzare GET e disabilitare tutta la memorizzazione nella cache, poiché si desidera registrare ogni query per queste risorse. Se la marcatura dei record ha un altro scopo, POST è la strada da percorrere. L'utente dovrebbe sapere che le sue azioni incidono sul sistema e sul metodo POST è un avvertimento.

Penso che il modo più semplice sia semplicemente usare AttributeRouting.

È ovvio nel tuo controller, perché dovresti volerlo nel tuo WebApiConfigfile Global ?

Esempio:

    [Route("api/YOURCONTROLLER/{paramOne}/{paramTwo}")]
    public string Get(int paramOne, int paramTwo)
    {
        return "The [Route] with multiple params worked";
    }

I {}nomi devono corrispondere ai tuoi parametri.

Semplice come quello, ora hai un separato GETche gestisce più parametri in questa istanza.

Aggiungi un nuovo percorso alle WebApiConfigvoci.

Ad esempio, per chiamare:

public IEnumerable<SampleObject> Get(int pageNumber, int pageSize) { ..

Inserisci:

config.Routes.MapHttpRoute(
    name: "GetPagedData",
    routeTemplate: "api/{controller}/{pageNumber}/{pageSize}"
);

Quindi aggiungere i parametri alla chiamata HTTP:

GET //<service address>/Api/Data/2/10 

Ho dovuto implementare un API RESTfull dove ho bisogno di passare i parametri. L'ho fatto passando i parametri nella stringa di query nello stesso stile descritto dal primo esempio di Mark "api / controller? Start = date1 & end = date2"

Nel controller ho usato un suggerimento da URL diviso in C #?

// uri: /api/courses
public IEnumerable<Course> Get()
{
    NameValueCollection nvc = HttpUtility.ParseQueryString(Request.RequestUri.Query);
    var system = nvc["System"];
    // BL comes here
    return _courses;
}

Nel mio caso stavo chiamando il WebApi via Ajax come:

$.ajax({
        url: '/api/DbMetaData',
        type: 'GET',
        data: { system : 'My System',
                searchString: '123' },
        dataType: 'json',
        success: function (data) {
                  $.each(data, function (index, v) {
                  alert(index + ': ' + v.name);
                  });
         },
         statusCode: {
                  404: function () {
                       alert('Failed');
                       }
        }
   });

Spero che aiuti...

Ho trovato un'ottima soluzione su http://habrahabr.ru/post/164945/

public class ResourceQuery
{
   public string Param1 { get; set; }
   public int OptionalParam2 { get; set; }
}

public class SampleResourceController : ApiController
{
    public SampleResourceModel Get([FromUri] ResourceQuery query)
    {
        // action
    }
}

L'uso di GET o POST è chiaramente spiegato da @LukLed . Per quanto riguarda il modo in cui è possibile passare i parametri, suggerirei di seguire il secondo approccio (non so molto su ODATA ).

1.Serializzare i parametri in una singola stringa JSON e selezionarli nell'API. http://forums.asp.net/t/1807316.aspx/1

Questo non è facile da usare e SEO friendly

2.Inserire i parametri nella stringa della query. Qual è il modo migliore per passare più parametri di query a un API riposante?

Questo è il solito approccio preferibile.

3.Definizione dei parametri nel percorso: api / controller / date1 / date2

Questo non è sicuramente un buon approccio. Questo fa sentire che qualcuno date2è una sotto-risorsa date1e non è così. Sia l' date1e date2sono parametri di query e arriva allo stesso livello.

In casi semplici suggerirei un URI come questo,

api/controller?start=date1&end=date2

Ma personalmente mi piace il modello URI di seguito, ma in questo caso dobbiamo scrivere un codice personalizzato per mappare i parametri.

api/controller/date1,date2

Utilizzare il parametro Binding come descritto qui: http://www.asp.net/web-api/overview/formats-and-model-binding/parameter-binding-in-aspnet-web-api

 [Route("api/controller/{one}/{two}")]
    public string Get(int One, int Two)
    {
        return "both params of the root link({one},{two}) and Get function parameters (one, two)  should be same ";
    }

Entrambi i parametri del collegamento radice ({one}, {two}) e i parametri della funzione Get (uno, due) devono essere uguali

So che è davvero vecchio, ma di recente ho voluto la stessa cosa ed ecco cosa ho trovato ...

    public HttpResponseMessage Get([FromUri] string var, [FromUri] string test) {
        var retStr = new HttpResponseMessage(HttpStatusCode.OK);
        if (var.ToLower() == "getnew" && test.ToLower() == "test") {
            retStr.Content = new StringContent("Found Test", System.Text.Encoding.UTF8, "text/plain");
        } else {
            retStr.Content = new StringContent("Couldn't Find that test", System.Text.Encoding.UTF8, "text/plain");
        }

        return retStr;
    }

Quindi ora nel tuo indirizzo / URI / ...

http (s): // myURL / api / myController / var = getnew & Test = test

Risultato: "test trovato"

http (s): // myURL / api / myController / var = getnew & test = nulla

Risultato: "Impossibile trovare quel test"

Ora puoi farlo semplicemente usando

        public string Get(int id, int abc)
        {
            return "value: " + id + "  " + abc;
        }

questo restituirà: "valore: 5 10"

se lo chiami con https: // tuodominio / api / tuocontrollore? id = 5 & abc = 10

    public HttpResponseMessage Get(int id,string numb)
    {
        //this will differ according to your entity name
        using (MarketEntities entities = new MarketEntities())
        {
          var ent=  entities.Api_For_Test.FirstOrDefault(e => e.ID == id && e.IDNO.ToString()== numb);
            if (ent != null)
            {
                return Request.CreateResponse(HttpStatusCode.OK, ent);
            }
            else
            {
                return Request.CreateErrorResponse(HttpStatusCode.NotFound, "Applicant with ID " + id.ToString() + " not found in the system");
            }
        }
    }