MVC3 REST Rutas y verbos Http

Question

Como resultado de un previous question mío, he descubierto dos formas de manejar rutas REST en MVC3.

Esta es una pregunta de seguimiento en la que trato de aprender las diferencias/sutilezas entre estos dos enfoques. Estoy buscando una respuesta autorizada si es posible.

Método 1: Ruta individual, con el nombre Acción + Http verbal atributos en acciones del controlador

1. Register una sola ruta en Global.asax usando un action parámetro especificado.

   public override void RegisterArea(AreaRegistrationContext context) 
   { 
       // actions should handle: GET, POST, PUT, DELETE 
       context.MapRoute("Api-SinglePost", "api/posts/{id}", 
        new { controller = "Posts", action = "SinglePost" }); 
   } 
   

2. se aplican tanto ActionName y HttpVerb atribuye a acciones de controladores

   [HttpGet] 
   [ActionName("SinglePost")] 
   public JsonResult Get(string id) 
   { 
       return Json(_service.Get(id)); 
   } 
   [HttpDelete] 
   [ActionName("SinglePost")] 
   public JsonResult Delete(string id) 
   { 
       return Json(_service.Delete(id)); 
   } 
   [HttpPost] 
   [ActionName("SinglePost")] 
   public JsonResult Create(Post post) 
   { 
       return Json(_service.Save(post)); 
   } 
   [HttpPut] 
   [ActionName("SinglePost")] 
   public JsonResult Update(Post post) 
   { 
       return Json(_service.Update(post);); 
   } 
   

Método 2: Rutas únicos + Limitaciones del verbo, con Http verbo atributo en las acciones del controlador

1. Registro rutas únicas en Global.asax con HttpMethodContraint

   var postsUrl = "api/posts"; 
   
   routes.MapRoute("posts-get", postsUrl + "/{id}", 
       new { controller = "Posts", action = "Get", 
       new { httpMethod = new HttpMethodConstraint("GET") }); 
   
   routes.MapRoute("posts-create", postsUrl, 
       new { controller = "Posts", action = "Create", 
       new { httpMethod = new HttpMethodConstraint("POST") }); 
   
   routes.MapRoute("posts-update", postsUrl, 
       new { controller = "Posts", action = "Update", 
       new { httpMethod = new HttpMethodConstraint("PUT") }); 
   
   routes.MapRoute("posts-delete", postsUrl + "/{id}", 
       new { controller = "Posts", action = "Delete", 
       new { httpMethod = new HttpMethodConstraint("DELETE") }); 
   

2. Use sólo un HTTP verbo atributo en las acciones del controlador

   [HttpGet] 
   public JsonResult Get(string id) 
   { 
       return Json(_service.Get(id)); 
   } 
   [HttpDelete] 
   public JsonResult Delete(string id) 
   { 
       return Json(_service.Delete(id)); 
   } 
   [HttpPost] 
   public JsonResult Create(Post post) 
   { 
       return Json(_service.Save(post)); 
   } 
   [HttpPut] 
   public JsonResult Update(Post post) 
   { 
       return Json(_service.Update(post);); 
   } 
   

Ambos métodos me dejó tener un nombre único Métodos acción del controlador, y permitir rutas RESTful vinculadas a los verbos ... pero ¿qué es inherentemente diferente sobre la restricción de la ruta frente a usar un nombre de acción de proxy?

Answer 1

No sé si alguna vez encontrará una respuesta autorizada, pero ofreceré mi opinión y, como puede ver por mis puntos, mi opinión importa ;-). Mi yo purista piensa que la primera opción es más pura, sin embargo, mi experiencia ha sido que los métodos auxiliares como Url.Action() a veces pueden tener problemas para resolver la ruta correcta con este enfoque y he tomado el segundo método, ya que realmente solo tiene implicaciones internamente ya que la API parece idéntica al consumidor.

Answer 2

Usted no recibirá una respuesta autorizada por aquí son mis 2 centavos:

prefiero el método 2, porque entonces usted tiene toda su enrutamiento en un solo lugar. Puede encapsular su enrutamiento en un método, p. MapResourceRoutes(string controller, string uri) y lo usa varias veces en su API.

También el método 2 le proporciona rutas claramente nombradas que puede usar para vincular y enrutar en reversa.

Answer 3

En este punto, la respuesta correcta es usar Web API.