A versão 4 do ASP.NET MVC foi lançada em 15 de Agosto de 2012. Se você é como eu e acompanha a evolução das tecnologias disponíveis na plataforma ASP.NET, deve se lembrar que a grande coqueluche (caramba, há quanto tempo não usava esta expressão?!) da versão 4 da framework MVC foi o ASP.NET Web API. Podemos dizer que o ASP.NET Web API está para o MVC 4 assim como o ASP.NET Razor esteve para o MVC 3.
Desde o lançamento da última versão da framework MVC, muitas dúvidas surgiram (principalmente para desenvolvedores com pouca experiência no universo ASP.NET) em relação as diferenças entre as abordagens do MVC tradicional e do Web API. Sei disso por ler as muitas mensagens que recebo através deste site e conversas em eventos de comunidade e clientes.
Este post (que já está no pipeline há um bom tempo) tem como objetivo principal apresentar as principais diferenças entre as abordagens (MVC tradicional versus Web API). Esta informação pode ser útil, por exemplo, no momento da decisão pela tecnologia utilizada em determinado projeto.
Disclaimer: estou assumindo aqui que você já conheça os conceitos (ao menos em nível básico) da framework MVC. Além disso, é importante salientar que este post não trata o assunto “Como utilizar o ASP.NET Web API”.
Primeira importante diferença: Roteamento
A primeira grande diferença que pude notar ao realizar a comparação entre projetos MVC tradicional e Web API foi: o mecanismo de rotas.
Como você deve se lembrar, uma aplicação MVC tradicional possui um mecanismo de rota bem definido, que associa os nomes dos controladores (controllers), suas respectivas ações (actions) e os valores de parâmetros que chegam para estas actions. Não há desta forma, uma relação direta com o verbo HTTP.
O modelo de roteamento proposto pelo Web API é diferente. Ele possui uma implementação consideravelmente maior (maior abstração) de lógica (por baixo do capo, é claro) e aqui, o protocolo HTTP exerce um papel fundamental no roteamento, uma vez que as amarrações são realizadas através dos verbos do protocolo e seus respetivos parâmetros.
Para que estes conceitos fiquem mais claros, considere os códigos apresentados pelas Listagens 1 e 2 (a seguir).
[code lang=”c-sharp”]
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;
namespace DiferencasEntreModelosDeRoteamento.Controllers
{
public class RotaDoModeloMVCController : Controller
{
//
// GET: /RotaDoModeloMVC/
public ActionResult Index()
{
return View();
}
//
// GET: /RotaDoModeloMVC/Details/5
public ActionResult Details(int id)
{
return View();
}
//
// GET: /RotaDoModeloMVC/Create
public ActionResult Create()
{
return View();
}
//
// POST: /RotaDoModeloMVC/Create
[HttpPost]
public ActionResult Create(FormCollection collection)
{
try
{
// TODO: Add insert logic here
return RedirectToAction(“Index”);
}
catch
{
return View();
}
}
//
// GET: /RotaDoModeloMVC/Edit/5
public ActionResult Edit(int id)
{
return View();
}
//
// POST: /RotaDoModeloMVC/Edit/5
[HttpPost]
public ActionResult Edit(int id, FormCollection collection)
{
try
{
// TODO: Add update logic here
return RedirectToAction(“Index”);
}
catch
{
return View();
}
}
//
// GET: /RotaDoModeloMVC/Delete/5
public ActionResult Delete(int id)
{
return View();
}
//
// POST: /RotaDoModeloMVC/Delete/5
[HttpPost]
public ActionResult Delete(int id, FormCollection collection)
{
try
{
// TODO: Add delete logic here
return RedirectToAction(“Index”);
}
catch
{
return View();
}
}
}
}
[/code]
Listagem 1. Um controlador MVC tradicional com métodos CRUD vazios
[code lang=”c-sharp”]
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Web.Http;
namespace DiferencasEntreModelosDeRoteamento.Controllers
{
public class RotaDeModeloWebAPIController : ApiController
{
// GET api/rotademodelowebapi
public IEnumerable Get()
{
return new string[] { “value1”, “value2” };
}
// GET api/rotademodelowebapi/5
public string Get(int id)
{
return “value”;
}
// POST api/rotademodelowebapi
public void Post([FromBody]string value)
{
}
// PUT api/rotademodelowebapi/5
public void Put(int id, [FromBody]string value)
{
}
// DELETE api/rotademodelowebapi/5
public void Delete(int id)
{
}
}
}
[/code]
Listagem 2. Uma rota Web API com os mesmos métodos
Com uma simples observação dos dois modelos de controladores, fica fácil evidenciar as diferentes abordagens disponibilizadas pela framework MVC.
Além das ideias apresentadas anteriormente (no início da discussão deste tópico), um aspecto a ser notado aqui é o modelo de roteamento seguido pelas abordagens. Enquanto no modelo MVC temos o padrão definido “{controller}/{action}/{id}“, no modelo do Web API temos o padrão “api/{controller}/{id}“.
Uma observação importante em relação ao padrão de rota do modelo Web API é: a fração “api” da definição é apenas uma convenção criada para que não haja conflito entre controladores Web API e MVC tradicionais no mesmo projeto.
Quando disse anteriormente que a abstração implementada para o modelo Web API é maior, não estava mentindo. Note, existe na Listagem 2 uma implementação da action “Get“, entretanto, no comentário associado à implementação do método, existe um exemplo de como chamar esta ação. Temos: “api/rotademodelowebapi/5“. Note que, muito embora a implementação seja do método Get, temos a chamada para {rotademodelowebapi}. Isso somente é possível graças a abstração do framework (uma das novidades da versão 4).
Segunda importante diferença: Diferentes focos
Muito embora ambas as abordagens possam ser partes constituintes do mesmo projeto, controladores MVC tradicionais e Web API mantém focos extremamente diferentes.
Enquanto ASP.NET MVC tradicional mantém seu foco nitidamente no retorno de views e seus dados intrínsecos, ASP.NET Web API mantém seu foco no retorno exclusivo dos dados através da chamada de serviços restfull, “sem se preocupar” com a forma com que estes serão exibidos.
Era isso. Espero que este conteúdo possa ser útil para elucidar eventuais dúvidas persistentes acerca do modelo.
Até a próxima!
Facebook
Twitter
Instagram
LinkedIn
RSS