Routage avec plusieurs méthodes Get dans l'API Web ASP.NET
J'utilise Web Api avec ASP.NET MVC et je suis très novice dans ce domaine. J'ai visionné une démo sur le site asp.net et j'essaie de faire ce qui suit.
J'ai 4 méthodes get, avec les signatures suivantes
public List<Customer> Get()
{
// gets all customer
}
public List<Customer> GetCustomerByCurrentMonth()
{
// gets some customer on some logic
}
public Customer GetCustomerById(string id)
{
// gets a single customer using id
}
public Customer GetCustomerByUsername(string username)
{
// gets a single customer using username
}
Pour toutes les méthodes ci-dessus, j'aimerais que mon api Web ressemble à ce qui suit.
- List Get () =
api/customers/ - Client GetCustomerById (string id) =
api/customers/13 - Liste GetCustomerByCurrentMonth () =
/customers/currentMonth - Client GetCustomerByUsername (nom d'utilisateur de la chaîne) =
/customers/customerByUsername/yasser
J'ai essayé de modifier le routage, mais comme je suis novice, je ne pouvais pas comprendre beaucoup.
Alors, s'il vous plaît, quelqu'un peut-il m'aider à comprendre et à me guider sur la manière de procéder Merci
À partir d'ici Routage dans Asp.net Mvc 4 et Web Api
Darin Dimitrov a posté une très bonne réponse qui fonctionne pour moi.
Ça dit...
Vous pouvez avoir plusieurs itinéraires:
public static class WebApiConfig
{
public static void Register(HttpConfiguration config)
{
config.Routes.MapHttpRoute(
name: "ApiById",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional },
constraints: new { id = @"^[0-9]+$" }
);
config.Routes.MapHttpRoute(
name: "ApiByName",
routeTemplate: "api/{controller}/{action}/{name}",
defaults: null,
constraints: new { name = @"^[a-z]+$" }
);
config.Routes.MapHttpRoute(
name: "ApiByAction",
routeTemplate: "api/{controller}/{action}",
defaults: new { action = "Get" }
);
}
}
Tout d’abord, ajoutez une nouvelle route avec action en haut:
config.Routes.MapHttpRoute(
name: "ActionApi",
routeTemplate: "api/{controller}/{action}/{id}",
defaults: new { id = RouteParameter.Optional }
);
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
Utilisez ensuite l'attribut ActionName pour mapper:
[HttpGet]
public List<Customer> Get()
{
//gets all customer
}
[ActionName("CurrentMonth")]
public List<Customer> GetCustomerByCurrentMonth()
{
//gets some customer on some logic
}
[ActionName("customerById")]
public Customer GetCustomerById(string id)
{
//gets a single customer using id
}
[ActionName("customerByUsername")]
public Customer GetCustomerByUsername(string username)
{
//gets a single customer using username
}
Aussi, vous spécifierez route sur action pour route définie
[HttpGet]
[Route("api/customers/")]
public List<Customer> Get()
{
//gets all customer logic
}
[HttpGet]
[Route("api/customers/currentMonth")]
public List<Customer> GetCustomerByCurrentMonth()
{
//gets some customer
}
[HttpGet]
[Route("api/customers/{id}")]
public Customer GetCustomerById(string id)
{
//gets a single customer by specified id
}
[HttpGet]
[Route("api/customers/customerByUsername/{username}")]
public Customer GetCustomerByUsername(string username)
{
//gets customer by its username
}
Un seul itinéraire suffit pour cela
config.Routes.MapHttpRoute("DefaultApiWithAction", "{controller}/{action}");
Et besoin pour spécifier l'attribut HttpGet ou HttpPost dans toutes les actions.
[HttpGet]
public IEnumerable<object> TestGet1()
{
return new string[] { "value1", "value2" };
}
[HttpGet]
public IEnumerable<object> TestGet2()
{
return new string[] { "value3", "value4" };
}
Il y a déjà beaucoup de bonnes réponses à cette question. Cependant, de nos jours, la configuration de Route est en quelque sorte "obsolète". La nouvelle version de MVC (.NET Core) ne la prend pas en charge. Donc, mieux vaut s'y habituer :)
Je suis donc d'accord avec toutes les réponses qui utilisent le routage de style Attribut. Mais je continue à remarquer que tout le monde a répété la partie de base de la route (api/...). Il est préférable d'appliquer un attribut [RoutePrefix] au-dessus de la classe de contrôleur et de ne pas répéter la même chaîne encore et encore.
[RoutePrefix("api/customers")]
public class MyController : Controller
{
[HttpGet]
public List<Customer> Get()
{
//gets all customer logic
}
[HttpGet]
[Route("currentMonth")]
public List<Customer> GetCustomerByCurrentMonth()
{
//gets some customer
}
[HttpGet]
[Route("{id}")]
public Customer GetCustomerById(string id)
{
//gets a single customer by specified id
}
[HttpGet]
[Route("customerByUsername/{username}")]
public Customer GetCustomerByUsername(string username)
{
//gets customer by its username
}
}
Après avoir lu beaucoup de réponses, j'ai finalement compris.
Tout d'abord, j'ai ajouté 3 itinéraires différents dans WebApiConfig.cs
public static void Register(HttpConfiguration config)
{
// Web API configuration and services
// Web API routes
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "ApiById",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional },
constraints: new { id = @"^[0-9]+$" }
);
config.Routes.MapHttpRoute(
name: "ApiByName",
routeTemplate: "api/{controller}/{action}/{name}",
defaults: null,
constraints: new { name = @"^[a-z]+$" }
);
config.Routes.MapHttpRoute(
name: "ApiByAction",
routeTemplate: "api/{controller}/{action}",
defaults: new { action = "Get" }
);
}
Ensuite, supprimez ActionName, Route, etc. des fonctions du contrôleur. Donc, fondamentalement, ceci est mon contrôleur;
// GET: api/Countries/5
[ResponseType(typeof(Countries))]
//[ActionName("CountryById")]
public async Task<IHttpActionResult> GetCountries(int id)
{
Countries countries = await db.Countries.FindAsync(id);
if (countries == null)
{
return NotFound();
}
return Ok(countries);
}
// GET: api/Countries/tur
//[ResponseType(typeof(Countries))]
////[Route("api/CountriesByName/{anyString}")]
////[ActionName("CountriesByName")]
//[HttpGet]
[ResponseType(typeof(Countries))]
//[ActionName("CountryByName")]
public async Task<IHttpActionResult> GetCountriesByName(string name)
{
var countries = await db.Countries
.Where(s=>s.Country.ToString().StartsWith(name))
.ToListAsync();
if (countries == null)
{
return NotFound();
}
return Ok(countries);
}
Maintenant je peux courir avec les échantillons d'URL suivants (avec le nom et l'id);
http: // localhost: 49787/api/Pays/GetCountriesByName/France
J'ai deux méthodes get avec les mêmes ou sans paramètres
[Route("api/ControllerName/FirstList")]
[HttpGet]
public IHttpActionResult FirstList()
{
}
[Route("api/ControllerName/SecondList")]
[HttpGet]
public IHttpActionResult SecondList()
{
}
Il suffit de définir des itinéraires personnalisés dans la méthode AppStart=>WebApiConfig.cs =>> under register
config.Routes.MapHttpRoute(
name: "GetFirstList",
routeTemplate: "api/Controllername/FirstList"
);
config.Routes.MapHttpRoute(
name: "GetSecondList",
routeTemplate: "api/Controllername/SecondList"
);
using Routing.Models;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Web.Http;
namespace Routing.Controllers
{
public class StudentsController : ApiController
{
static List<Students> Lststudents =
new List<Students>() { new Students { id=1, name="kim" },
new Students { id=2, name="aman" },
new Students { id=3, name="shikha" },
new Students { id=4, name="ria" } };
[HttpGet]
public IEnumerable<Students> getlist()
{
return Lststudents;
}
[HttpGet]
public Students getcurrentstudent(int id)
{
return Lststudents.FirstOrDefault(e => e.id == id);
}
[HttpGet]
[Route("api/Students/{id}/course")]
public IEnumerable<string> getcurrentCourse(int id)
{
if (id == 1)
return new List<string>() { "emgili", "hindi", "pun" };
if (id == 2)
return new List<string>() { "math" };
if (id == 3)
return new List<string>() { "c#", "webapi" };
else return new List<string>() { };
}
[HttpGet]
[Route("api/students/{id}/{name}")]
public IEnumerable<Students> getlist(int id, string name)
{ return Lststudents.Where(e => e.id == id && e.name == name).ToList(); }
[HttpGet]
public IEnumerable<string> getlistcourse(int id, string name)
{
if (id == 1 && name == "kim")
return new List<string>() { "emgili", "hindi", "pun" };
if (id == 2 && name == "aman")
return new List<string>() { "math" };
else return new List<string>() { "no data" };
}
}
}
// this piece of code in the WebApiConfig.cs file or your custom bootstrap application class
// define two types of routes 1. DefaultActionApi and 2. DefaultApi as below
config.Routes.MapHttpRoute("DefaultActionApi", "api/{controller}/{action}/{id}", new { id = RouteParameter.Optional });
config.Routes.MapHttpRoute("DefaultApi", "api/{controller}/{id}", new { action = "Default", id = RouteParameter.Optional });
// decorate the controller action method with [ActionName("Default")] which need to invoked with below url
// http://localhost:XXXXX/api/Demo/ -- will invoke the Get method of Demo controller
// http://localhost:XXXXX/api/Demo/GetAll -- will invoke the GetAll method of Demo controller
// http://localhost:XXXXX/api/Demo/GetById -- will invoke the GetById method of Demo controller
// http://localhost:57870/api/Demo/CustomGetDetails -- will invoke the CustomGetDetails method of Demo controller
// http://localhost:57870/api/Demo/DemoGet -- will invoke the DemoGet method of Demo controller
public class DemoController : ApiController
{
// Mark the method with ActionName attribute (defined in MapRoutes)
[ActionName("Default")]
public HttpResponseMessage Get()
{
return Request.CreateResponse(HttpStatusCode.OK, "Get Method");
}
public HttpResponseMessage GetAll()
{
return Request.CreateResponse(HttpStatusCode.OK, "GetAll Method");
}
public HttpResponseMessage GetById()
{
return Request.CreateResponse(HttpStatusCode.OK, "Getby Id Method");
}
//Custom Method name
[HttpGet]
public HttpResponseMessage DemoGet()
{
return Request.CreateResponse(HttpStatusCode.OK, "DemoGet Method");
}
//Custom Method name
[HttpGet]
public HttpResponseMessage CustomGetDetails()
{
return Request.CreateResponse(HttpStatusCode.OK, "CustomGetDetails Method");
}
}
Vous n'aurez peut-être pas besoin de modifier le routage. Ajoutez simplement les quatre méthodes suivantes dans votre fichier customersController.cs:
public ActionResult Index()
{
}
public ActionResult currentMonth()
{
}
public ActionResult customerById(int id)
{
}
public ActionResult customerByUsername(string userName)
{
}
Mettez le code approprié dans la méthode. Avec le routage par défaut fourni, vous devriez obtenir le résultat d’action approprié du contrôleur en fonction de l’action et des paramètres de vos URL.
Modifiez votre itinéraire par défaut comme suit:
routes.MapRoute(
"Default", // Route name
"{controller}/{action}/{id}", // URL with parameters
new { controller = "Api", action = "Index", id = UrlParameter.Optional } // Parameter defaults
);