Wie soll ich mehrere Parameter an ein ASP.Net Web API GET übergeben?

Ich verwende die .NET MVC4-Web-API, um (hoffentlich) eine RESTful-API zu implementieren. Ich muss ein paar Parameter an das System übergeben und es eine Aktion ausführen lassen, um dann eine Liste von Objekten als Ergebnis zurückzugeben. Insbesondere übergebe ich zwei Daten und gebe Aufzeichnungen zurück, die zwischen ihnen liegen. Ich verfolge auch die zurückgegebenen Datensätze, damit nachfolgende Anrufe im System nicht erneut verarbeitet werden.

Ich habe einige Ansätze in Betracht gezogen:

1. Serialisieren der Parameter in eine einzelne JSON-Zeichenfolge und Auswählen in der API. http://forums.asp.net/t/1807316.aspx/1

2. Übergeben Sie die Parameter in der Abfragezeichenfolge.
   Was ist der beste Weg, um mehrere Abfrageparameter an eine erholsame API zu übergeben?

3. Definieren der Parameter in der Route: api / controller / date1 / date2

4. Verwenden eines POST, mit dem ich von Natur aus ein Objekt mit Parametern übergeben kann.

5. Erforschung von ODATA, da die Web-API dies (derzeit) unterstützt. Ich habe noch nicht viel damit gemacht, daher bin ich damit nicht sehr vertraut.

Es scheint, dass die richtigen REST-Praktiken anzeigen, wenn Daten abgerufen werden, sollten Sie ein GET verwenden. GET sollte jedoch auch nullipotent sein (erzeugt keine Nebenwirkungen), und ich frage mich, ob meine spezifische Implementierung dies verletzt, da ich Datensätze im API-System markiere und daher Nebenwirkungen hervorrufe.

Es führte mich auch zur Frage der Unterstützung variabler Parameter. Wenn sich die Eingabeparameterliste ändert, wäre es mühsam, Ihre Route für Auswahl 3 neu zu definieren, wenn dies häufig vorkommt. Und was kann passieren, wenn die Parameter zur Laufzeit definiert werden ...

Welche Auswahl (falls vorhanden) scheint für meine spezifische Implementierung auf jeden Fall am besten zu sein?

Was bedeutet diese Rekordkennzeichnung? Wenn dies nur zu Protokollierungszwecken verwendet wird, würde ich GET verwenden und das gesamte Caching deaktivieren, da Sie jede Abfrage für diese Ressourcen protokollieren möchten. Wenn die Datensatzmarkierung einen anderen Zweck hat, ist POST der richtige Weg. Der Benutzer sollte wissen, dass seine Aktionen das System beeinflussen und die POST-Methode eine Warnung ist.

Ich denke, der einfachste Weg ist, einfach zu benutzen AttributeRouting.

In Ihrem Controller ist klar, warum Sie dies in Ihrer globalen WebApiConfigDatei wünschen .

Beispiel:

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

Die {}Namen müssen Ihren Parametern entsprechen.

So einfach ist das. Jetzt haben Sie eine separate GETDatei, die in dieser Instanz mehrere Parameter verarbeitet.

Fügen Sie einfach eine neue Route zu den WebApiConfigEinträgen hinzu.

Zum Beispiel, um anzurufen:

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

hinzufügen:

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

Fügen Sie dann die Parameter zum HTTP-Aufruf hinzu:

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

Ich musste nur eine RESTfull-API implementieren, in der ich Parameter übergeben muss. Dazu habe ich die Parameter in der Abfragezeichenfolge im gleichen Stil übergeben, wie er in Marks erstem Beispiel "api / controller? Start = date1 & end = date2" beschrieben wurde.

Im Controller habe ich einen Tipp von URL verwendet, der in C # aufgeteilt ist.

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

In meinem Fall rief ich das WebApi über Ajax an und sah aus wie folgt:

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

Ich hoffe das hilft...

Ich habe auf http://habrahabr.ru/post/164945/ eine hervorragende Lösung gefunden.

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

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

Die Verwendung von GET oder POST wird durch @LukLed klar erklärt . In Bezug auf die Art und Weise, wie Sie die Parameter übergeben können, würde ich vorschlagen, den zweiten Ansatz zu wählen (ich weiß auch nicht viel über ODATA ).

1.Serialisieren Sie die Parameter in eine einzelne JSON-Zeichenfolge und nehmen Sie sie in der API auseinander. http://forums.asp.net/t/1807316.aspx/1

Dies ist nicht benutzerfreundlich und SEO-freundlich

2. Übergeben Sie die Parameter in der Abfragezeichenfolge. Was ist der beste Weg, um mehrere Abfrageparameter an eine erholsame API zu übergeben?

Dies ist der übliche bevorzugte Ansatz.

3.Definieren der Parameter in der Route: api / controller / date1 / date2

Dies ist definitiv kein guter Ansatz. Dies gibt dem Gefühl, dass jemand date2eine Unterressource von ist, date1und das ist nicht der Fall. Sowohl die date1als auch date2sind Abfrageparameter und befinden sich auf derselben Ebene.

Im einfachen Fall würde ich eine URI wie diese vorschlagen,

api/controller?start=date1&end=date2

Ich persönlich mag das folgende URI-Muster, aber in diesem Fall müssen wir einen benutzerdefinierten Code schreiben, um die Parameter abzubilden.

api/controller/date1,date2

Verwenden Sie die Parameterbindung wie hier vollständig beschrieben: 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 ";
    }

Beide Parameter des Root-Links ({eins}, {zwei}) und der Get-Funktionsparameter (eins, zwei) sollten identisch sein

Ich weiß, dass dies wirklich alt ist, aber ich wollte das Gleiche in letzter Zeit und hier ist, was ich gefunden habe ...

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

Also jetzt in deiner Adresse / URI / ...

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

Ergebnis: "Gefundener Test"

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

Ergebnis: "Dieser Test konnte nicht gefunden werden"

Jetzt können Sie dies einfach mit verwenden

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

Dies gibt Folgendes zurück: "Wert: 5 10"

Wenn Sie es mit https: // yourdomain / api / yourcontroller aufrufen? 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");
            }
        }
    }