Comment dois-je transmettre plusieurs paramètres à une API Web ASP.Net GET?

J'utilise l'API Web .Net MVC4 pour implémenter (espérons-le) une API RESTful. Je dois transmettre quelques paramètres au système et lui faire effectuer une action, puis renvoyer une liste d'objets en tant que résultats. Plus précisément, je passe deux dates et je renvoie les enregistrements qui se situent entre elles. Je garde également une trace des enregistrements renvoyés afin que les appels suivants ne soient pas retraités dans le système.

J'ai envisagé quelques approches:

1. Sérialisation des paramètres en une seule chaîne JSON et sélection de celle-ci dans l'API. http://forums.asp.net/t/1807316.aspx/1

2. Passez les paramètres dans la chaîne de requête.
   Quelle est la meilleure façon de transmettre plusieurs paramètres de requête à une API reposante?

3. Définition des paramètres de la route: api / controller / date1 / date2

4. En utilisant un POST qui me permet intrinsèquement de passer un objet avec des paramètres.

5. Recherche ODATA puisque l'API Web (actuellement) le prend en charge. Je n'ai pas encore fait grand chose avec cela, donc je ne suis pas très familier avec cela.

Il semble que les bonnes pratiques REST indiquent que lorsque les données sont extraites, vous devez utiliser un GET. Cependant, GET devrait également être nullipotent (ne produit aucun effet secondaire), et je me demande si mon implémentation spécifique viole cela puisque je marque des enregistrements dans le système API, donc je produis des effets secondaires.

Cela m'a également conduit à la question de la prise en charge des paramètres variables. Si la liste des paramètres d'entrée change, il serait fastidieux de redéfinir votre itinéraire pour le choix 3 si cela se produit souvent. Et que peut-il se passer si les paramètres sont définis au moment de l'exécution ...

Dans tous les cas, pour mon implémentation spécifique, quel choix (le cas échéant) me semble le mieux?

Que signifie ce marquage d'enregistrement? Si cela n'est utilisé qu'à des fins de journalisation, j'utiliserais GET et désactiverais toute la mise en cache, car vous souhaitez enregistrer chaque requête pour ces ressources. Si le marquage des enregistrements a un autre but, POST est la voie à suivre. L'utilisateur doit savoir que ses actions affectent le système et la méthode POST est un avertissement.

Je pense que le moyen le plus simple est simplement d'utiliser AttributeRouting.

C'est évident dans votre contrôleur, pourquoi voudriez-vous cela dans votre WebApiConfigfichier Global ?

Exemple:

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

Les {}noms doivent correspondre à vos paramètres.

Aussi simple que cela, vous avez maintenant un autre GETqui gère plusieurs paramètres dans cette instance.

Ajoutez simplement un nouvel itinéraire aux WebApiConfigentrées.

Par exemple, pour appeler:

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

ajouter:

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

Ajoutez ensuite les paramètres à l'appel HTTP:

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

Je devais juste implémenter une API RESTfull où je devais passer des paramètres. Je l'ai fait en passant les paramètres dans la chaîne de requête dans le même style que celui décrit par le premier exemple de Mark "api / controller? Start = date1 & end = date2"

Dans le contrôleur, j'ai utilisé une astuce de l' URL fractionnée en C #?

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

Dans mon cas, j'appelais le WebApi via Ajax ressemblant à:

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

J'espère que ça aide...

J'ai trouvé une excellente solution sur 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'utilisation de GET ou POST est clairement expliquée par @LukLed . En ce qui concerne les façons dont vous pouvez passer les paramètres, je suggérerais d'utiliser la deuxième approche (je ne sais pas grand-chose non plus sur ODATA ).

1) Sérialisation des paramètres en une seule chaîne JSON et sélection de celle-ci dans l'API. http://forums.asp.net/t/1807316.aspx/1

Ce n'est pas convivial et convivial pour le référencement

2.Passez les paramètres dans la chaîne de requête. Quelle est la meilleure façon de transmettre plusieurs paramètres de requête à une API reposante?

Il s'agit de l'approche généralement préférable.

3.Définir les paramètres de la route: api / controller / date1 / date2

Ce n'est certainement pas une bonne approche. Cela donne l'impression que quelqu'un date2est une ressource secondaire date1et ce n'est pas le cas. Les deux date1et date2sont des paramètres de requête et sont au même niveau.

Dans le cas simple, je suggérerais un URI comme celui-ci,

api/controller?start=date1&end=date2

Mais j'aime personnellement le modèle d'URI ci-dessous, mais dans ce cas, nous devons écrire du code personnalisé pour mapper les paramètres.

api/controller/date1,date2

Utilisez la liaison de paramètres comme décrit complètement ici: 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 ";
    }

Les deux paramètres du lien racine ({un}, {deux}) et les paramètres de la fonction Get (un, deux) doivent être identiques

Je sais que c'est vraiment vieux, mais je voulais la même chose récemment et voici ce que j'ai trouvé ...

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

Alors maintenant dans votre adresse / URI / ...

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

Résultat: "Test trouvé"

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

Résultat: "Impossible de trouver ce test"

Vous pouvez maintenant le faire en utilisant simplement

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

cela renverra: "valeur: 5 10"

si vous l' appelez avec https: // yourdomain / api / yourcontroller? 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");
            }
        }
    }