Neste artigo, vamos criar uma aplicação ASP .NET MVC 6 Web API usando o Visual Studio Community 2015. Será uma aplicação básica onde iremos realizar as operações CRUD na API Contatos.
A ASP .NET Web API é um framework que torna bem simples construir serviços HTTP que alcançam uma grande variedade de clientes como navegadores, tablets, smartphones etc, sendo ideal para criar aplicações RESTful na plataforma .NET.
Neste artigo, iremos realizar as seguintes tarefas:
- Criar uma projeto ASP .NET Core Web API
- Criar o modelo de domínio(Model) Contatos
- Criar e registrar um repositório para os Contatos
- Adicionar o Controlador
- Definir os métodos CRUD
- Testar A Web API
Recursos usados:
- Visual Studio Community com Update 2
- ASP .NET Core RC 2
- Visual Studio official MSI Installer
- NuGet Manager extension for Visual Studio
Criando sua primeira aplicação ASP .NET MVC 6 Web API
Abra o Visual Studio Community 2015 com update 2 e clique em New Project. Depois, selecione Visual C# e clique em Web.
Você verá a janela abaixo exibindo dois novos tipos de projetos web:
Os dois tipos de projetos são:
- ASP.NET Core Web Application (.NET Core) – Projeto ASP.NET Core multiplataforma (Windows, Linux e OS X) , baseado no .NET Core;
- ASP.NET Core Web Application (.NET Framework) – Projeto ASP.NET Core que emprega o .NET Framework, apenas para o ambiente Windows.
Vamos criar um projeto ASP .NET Core Multiplataforma com o nome WebAPI_Contatos:
Ao clicar no botão OK, veremos na próxima janela 3 templates disponíveis:
- Empty
- Web API
- Web Application
Marque a opção Web API sem autenticação e sem hospedagem na nuvem e clique no botão OK.
Você verá na janela Solution Explorer a seguinte estrutura do projeto criado:
Em destaque temos a exibição do código da classe Program.cs.
Lembra que mencionei que ASP .NET Core é uma aplicação Console? Observe que temos o método Main() onde a aplicação será configurada e executada (este método antes estava no arquivo startup.cs).
Se abrirmos o arquivo project.json veremos a versão da ASP .NET Core e as dependências do MVC, EnvirnomentVariables, JSON e Loggingincluídas no projeto:
Definindo o modelo de domínio : Contato
Vamos criar a classe Contatos em uma pasta Models, que iremos criar no projeto. Será uma classe POCO bem simples.
Selecione o projeto WebAPI_Contatos e no menu Project e clique em New Folder e informe o nome Models. Agora clique com o botão direito sobre a pasta Models e a seguir em Add -> Class informando o nome Contato.cs.
Inclua o código abaixo nesta classe:
public class Contato { public string Nome { get; set; } public string Sobrenome { get; set; } public bool IsParente { get; set; } public string Empresa { get; set; } public string Email { get; set; } public string Telefone { get; set; } public DateTime Nascimento { get; set; } }
Criando o repositório de dados para os Contatos
Vamos usar o padrão repositório para desacoplar a nossa camada de acesso a dados da ferramenta ORM.
Vamos criar uma interface IContatosRepositorio na pasta Models. Para isso, selecione a pasta Models e no menu Project clique em Add New Item e selecione o template Interface informando o nomeIContatosRepositorio.
A seguir, inclua o código abaixo nesta interface:
public interface IContatosRepositorio { void Adicionar(Contato item); IEnumerable<Contato> GetTodos(); Contato Encontrar(string chave); void Remover(string Id); void Atualizar(Contato item); }
Nossa interface definiu os métodos básicos para realizar as operações CRUD e que deverão ser implementadas pela classe concretaContatosRepositorio.
No menu Project, clique em Add Class e informe o nome ContatosRepositorio.cs.
Inclua o código abaixo nesta classe:
public class ContatosRepositorio : IContatosRepositorio { <strong>static List<Contato> ListaContatos = new List<Contato>();</strong> public void Adicionar(Contato item) { ListaContatos.Add(item); } public void Atualizar(Contato item) { var itemAtualizar = ListaContatos.SingleOrDefault(r => r.Telefone == item.Telefone); if (itemAtualizar != null) { itemAtualizar.Nome = item.Nome; itemAtualizar.Sobrenome = item.Sobrenome; itemAtualizar.IsParente = item.IsParente; itemAtualizar.Empresa = item.Empresa; itemAtualizar.Email = item.Email; itemAtualizar.Telefone = item.Telefone; itemAtualizar.Nascimento = item.Nascimento; } } public Contato Encontrar(string chave) { return ListaContatos.Where(e => e.Telefone.Equals(chave)).FirstOrDefault(); } public IEnumerable<Contato> GetTodos() { return ListaContatos; } public void Remover(string Id) { var itemARemover = ListaContatos.SingleOrDefault(r => r.Telefone == Id); if (ListaContatos != null) ListaContatos.Remove(itemARemover); } }
Nesta classe implementamos os métodos definidos na interface.
Observe que não estamos trabalhando com um banco de dados para simplificar o projeto. Mais adiante vamos realizar a injeção de dependência usando o arquivo Startup.cs.
Criando o controlador ContatosController na pasta Controllers
Chegou a hora de definir o nosso controlador ContatosController na pasta Controllers.
Clique com o botão direito do mouse sobre a pasta Controllers e a seguir clique em Add Class e informe o nome ContatosController.cs.
Em seguida, inclua o código abaixo nesta classe:
using Microsoft.AspNetCore.Mvc; using System.Collections.Generic; using WebAPI_Contatos.Models; namespace WebAPI_Contatos.Controllers { [Route("api/[controller]")] <strong>public class ContatosController : Controller</strong> { public IContatosRepositorio contatosRepo { get; set; } public ContatosController(<strong>IContatosRepositorio</strong> _repo) { <strong>contatosRepo = _repo;</strong> } [HttpGet] public IEnumerable<Contato> GetTodos() { return <strong>contatosRepo.GetTodos();</strong> } [HttpGet("{id}", Name = "GetContatos")] public IActionResult GetPorId(string id) { var item = <strong>contatosRepo.Encontrar(id);</strong> if (item == null) { return NotFound(); } return new ObjectResult(item); } [HttpPost] public IActionResult Criar([FromBody] Contato item) { if (item == null) { return BadRequest(); } contatosRepo.Adicionar(item); return CreatedAtRoute("GetContatos", new { Controller = "Contatos", id = item.Telefone }, item); } [HttpPut("{id}")] public IActionResult Atualizar(string id, [FromBody] Contato item) { if (item == null) { return BadRequest(); } var contactObj = <strong>contatosRepo.Encontrar(id);</strong> if (contactObj == null) { return NotFound(); } <strong>contatosRepo.Atualizar(item);</strong> return new NoContentResult(); } [HttpDelete("{id}")] public void Deletar(string id) { <strong>contatosRepo.Remover(id);</strong> } } }
Os destaques deste código são:
- [Route(“api/[controller]”)] – Este atributo é usado para definir um roteamento para acessar a Web API;
- contatosRepo – É instanciado usando uma injeção de dependência que é configurada em services.cs;
- GetTodos() – É um método HttpGet para obter todos os contatos;
- GetPorId – É um método que vai procurar um contato com base no seu número de telefone;
- O método Criar depois de incluir um contato retorna 201 e fornece o header de localização.
Nota: Os código do status HTTP Status são descritos como: BadReqest(), NotFound(), Unauthorized() etc.
Ajustando o arquivo Startup.cs para rodar a Web API
Qualquer Web API irá retornar JSON no formato Camel Case de forma que possamos consumir a API em qualquer cliente.
Precisamos habilitar a classeCamelCasePropertyNamesContractResolver no método ConfigureServices do arquivo Startup.cs. E precisamos também definir a injeção de dependência usada no controlador.
A seguir, vemos o arquivo Startup.cs com o código já pronto:
using Microsoft.AspNetCore.Builder; using Microsoft.AspNetCore.Hosting; using Microsoft.Extensions.Configuration; using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.Logging; using Newtonsoft.Json.Serialization; using WebAPI_Contatos.Models; namespace WebAPI_Contatos { public class Startup { public Startup(IHostingEnvironment env) { var builder = new ConfigurationBuilder() .SetBasePath(env.ContentRootPath) .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true) .AddJsonFile(quot;appsettings.{env.EnvironmentName}.json", optional: true) .AddEnvironmentVariables(); Configuration = builder.Build(); } public IConfigurationRoot Configuration { get; } // This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { <strong>// Adicionando servicos do framework</strong> <strong> services.AddMvc()</strong> <strong> .AddJsonOptions(a => a.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver()); ;</strong> <strong> //usando a Dependency Injection</strong> <strong> services.AddSingleton<IContatosRepositorio, ContatosRepositorio>();</strong> } // This method gets called by the runtime. Use this method to configure the HTTP request pipeline. public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory) { loggerFactory.AddConsole(Configuration.GetSection("Logging")); loggerFactory.AddDebug(); app.UseMvc(); } } }
O código destacado em negrito foi o que incluímos no arquivo.
Na segunda parte do artigo vamos testar a nossa Web API realizando algumas operações CRUD que definimos no projeto.
Até mais!