ASP .NET Core – Criando uma aplicação MVC 6 Web API no VS 2015 Community – Parte 01

setembro 2, 2016 1:00 pm Publicado por Deixe um comentário

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

aspnc_mvc610

Recursos usados:

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:

aspn_corerc221 (1)

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:

aspnc_mvc611

Ao clicar no botão OK, veremos na próxima janela 3 templates disponíveis:

  • Empty
  • Web API
  • Web Application

aspnc_mvc612

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:

aspnc_mvc613

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:

aspnc_mvc614

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&lt;Contato&gt; ListaContatos = new List&lt;Contato&gt;();</strong>
        public void Adicionar(Contato item)
        {
             ListaContatos.Add(item);
        }
        public void Atualizar(Contato item)
        {
            var itemAtualizar = ListaContatos.SingleOrDefault(r =&gt; 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 =&gt; e.Telefone.Equals(chave)).FirstOrDefault();
        }
        public IEnumerable&lt;Contato&gt; GetTodos()
        {
               return ListaContatos;
        }
        public void Remover(string Id)
        {
            var itemARemover = ListaContatos.SingleOrDefault(r =&gt; 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&lt;Contato&gt; 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:

  1. [Route(“api/[controller]”)] – Este atributo é usado para definir um roteamento para acessar a Web API;
  2. contatosRepo – É instanciado usando uma injeção de dependência que é configurada em services.cs;
  3. GetTodos() – É um método HttpGet para obter todos os contatos;
  4. GetPorId – É um método que vai procurar um contato com base no seu número de telefone;
  5. 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($"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 =&gt; a.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver()); ;</strong>
<strong>            //usando a Dependency Injection</strong>
<strong>            services.AddSingleton&lt;IContatosRepositorio, ContatosRepositorio&gt;();</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!

Mensagem do anunciante:

Com a Directcall você automatiza telefonia no seu software e website em minutos! Teste grátis

Source: IMasters

Categorizados em:

Este artigo foi escrito pormajor

Deixe uma resposta

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *