ASP .NET Core - Criando uma Web API com CRUD básico - I

 Neste artigo eu vou mostrar como criar um CRUD básico em uma Web API com ASP .NET Core 2.0.

Vamos criar um projeto ASP .NET Core Empty e a seguir definir uma WEB API com um CRUD Basico.

Nossa Web API vai tratar informações de filmes e expor serviços para realizar as operações CRUD.

Podemos usar o Visual Studio 2017 Community com update 15.5.1 que foi disponibilizado no mês de dezembro de 2017 ou podemos usar a linha de comando com o Visual Studio Code.   

Vamos usar o Visual Studio Community 2017 neste artigo.

Recursos usados:

Criando o projeto no VS 2017

Abra o VS 2017 Community e crie um novo projeto ASP .NET Core usando o template Empty.

Ao final teremos o projeto conforme mostrado a seguir:

Definindo o Modelo de domínio

Vamos criar uma pasta Models no projeto usando o menu Project ->New Folder;

A seguir crie uma classe chamada Filme na pasta Models com o seguinte código:

    public class Filme
    {
        public int Id { get; set; }
        public string Titulo { get; set; }
        public int AnoLancamento { get; set; }
        public string Resumo { get; set; }
    }

A seguir vamos definir os modelos que iremos usar para expor informações da Web API. Seguimos essa abordagem para expor somente os dados que desejamos a quem vai consumir o serviço.

Para isso vamos definir dois modelos representandos pelas classes :

    public class FilmeOutputModel
    {
        public int Id { get; set; }
        public string Titulo { get; set; }
        public int AnoLancamento { get; set; }
        public string Resumo { get; set; }
        public DateTime UltimoAcesso { get; set ;}
    }
 
    public class FilmeInputModel
    {
        public int Id { get; set; }
        public string Titulo { get; set; }
        public int AnoLancamento { get; set; }
        public string Resumo { get; set; }
    }

Definindo o serviço : IFilmeService e FilmeService

Vamos definir no projeto uma serviço que será usado para fornecer informações sobre filmes.

Vamos criar uma pasta Service via menu Project->New Folder e a seguir criar uma interface chamada IFilmeService onde vamos definir os métodos do serviço que vamos usar segundo o código abaixo: 

using CrudWebAPIAspCore.Models;
using System.Collections.Generic;
namespace CrudWebAPIAspCore.Service
{
    public interface IFilmeService
    {
        List<Filme> GetFilmes();
        Filme GetFilme(int id);
        void AddFilme(Filme item);
        void UpdateFilme(Filme item);
        void DeleteFilme(int id);
        bool FilmeExists(int id);
    }
}

Na mesma pasta vamos criar a classe FilmeService que implementa a interface IFilmeService e que tem o código abaixo:

using CrudWebAPIAspCore.Models;
using System.Collections.Generic;
using System.Linq;

namespace CrudWebAPIAspCore.Service
{
    public class FilmeService : IFilmeService
    {
        private readonly List<Filme> filmes;

        public FilmeService()
        {
            this.filmes = new List<Filme>
            {
                new Filme { Id = 1, Titulo = "Moscou contra 007", AnoLancamento = 1983, Resumo = "um agente a serviço da SPECTRE, evela um plano de roubar o criptógrafo Lektor dos soviéticos e vendê-lo novamente aos mesmos, e simultaneamente se vingar de James pelo assassinato de Dr. No." },
                new Filme { Id = 2, Titulo = "Os diamentes são eternos", AnoLancamento = 1971, Resumo = "Bond é encarregado de investigar um misterioso fluxo de diamantes envolvendo África, Estados Unidos e Holanda. Disfarçado como  um contrabandista profissional de nome Peter Franks, Bond viaja a Amsterdão para contactar Tiffany Case." },
                new Filme { Id = 3, Titulo = "Só se vive duas vezes", AnoLancamento = 1967, Resumo = "O Agente 007 é enviado ao Japão para investigar o sequestro de uma nave espacial americana por forças desconhecidas. Logo ao chegar, Bond é contactado por Aki, assistente de Tiger Tanaka, do Serviço Secreto Japonês." }};
        }

        public void AddFilme(Filme item)
        {
            this.filmes.Add(item);
        }

        public void DeleteFilme(int id)
        {
            var model = this.filmes.Where(m => m.Id == id).FirstOrDefault();
            this.filmes.Remove(model);
        }

        public bool FilmeExists(int id)
        {
            return this.filmes.Any(m => m.Id == id);
        }

        public Filme GetFilme(int id)
        {
            return this.filmes.Where(m => m.Id == id).FirstOrDefault();
        }

        public List<Filme> GetFilmes()
        {
            return this.filmes.ToList();
        }

        public void UpdateFilme(Filme item)
        {
            var model = this.filmes.Where(m => m.Id == item.Id).FirstOrDefault();

            model.Titulo = item.Titulo;
            model.AnoLancamento = item.AnoLancamento;
            model.Resumo = item.Resumo;
        }
    }
}

Definimos os métodos para gerenciar e retornar informações sobre filmes :

Criando o controlador FilmesControllers

Agora vamos criar o controlador FilmesControllers que será a nossa API onde iremos definir os métodos CRUD.

using CrudWebAPIAspCore.Models;
using CrudWebAPIAspCore.Service;
using Microsoft.AspNetCore.Mvc;
using System;
using System.Collections.Generic;
using System.Linq;
namespace CrudWebAPIAspCore.Controllers
{
    [Route("filmes")]
    public class FilmesController : Controller
    {
        private readonly IFilmeService service;
        public FilmesController(IFilmeService service)
        {
            this.service = service;
        }
        [HttpGet]
        public IActionResult Get()
        {
            var model = service.GetFilmes();
            var outputModel = ToOutputModel(model);
            return Ok(outputModel);
        }
        [HttpGet("{id}", Name = "GetFilme")]
        public IActionResult Get(int id)
        {
            var model = service.GetFilme(id);
            if (model == null)
                return NotFound();
            var outputModel = ToOutputModel(model);
            return Ok(outputModel);
        }
        [HttpPost]
        public IActionResult Create([FromBody]FilmeInputModel inputModel)
        {
            if (inputModel == null)
                return BadRequest();
            var model = ToDomainModel(inputModel);
            service.AddFilme(model);
            var outputModel = ToOutputModel(model);
            return CreatedAtRoute("GetFilme",new { id = outputModel.Id }, outputModel);
        }
        [HttpPut("{id}")]
        public IActionResult Update(int id, [FromBody]FilmeInputModel inputModel)
        {
            if (inputModel == null || id != inputModel.Id)
                return BadRequest();
            if (!service.FilmeExists(id))
                return NotFound();
            var model = ToDomainModel(inputModel);
            service.UpdateFilme(model);
            return NoContent();
        }
        [HttpDelete("{id}")]
        public IActionResult Delete(int id)
        {
            if (!service.FilmeExists(id))
                return NotFound();
            service.DeleteFilme(id);
            return NoContent();
        }
        //--------------------------------------------------
        //Mapeamentos : modelos envia/recebe dados via API
        private FilmeOutputModel ToOutputModel(Filme model)
        {
            return new FilmeOutputModel
            {
                Id = model.Id,
                Titulo = model.Titulo,
                AnoLancamento = model.AnoLancamento,
                Resumo = model.Resumo,
                UltimoAcesso = DateTime.Now
            };
        }
        private List<FilmeOutputModel> ToOutputModel(List<Filme> model)
        {
            return model.Select(item => ToOutputModel(item)).ToList();
        }
        private Filme ToDomainModel(FilmeInputModel inputModel)
        {
            return new Filme
            {
                Id = inputModel.Id,
                Titulo = inputModel.Titulo,
                AnoLancamento = inputModel.AnoLancamento,
                Resumo = inputModel.Resumo
            };
        }
        private FilmeInputModel ToInputModel(Filme model)
        {
            return new FilmeInputModel
            {
                Id = model.Id,
                Titulo = model.Titulo,
                AnoLancamento = model.AnoLancamento,
                Resumo = model.Resumo
            };
        }
    }
}

O código do controlador utiliza os métodos do nosso serviço para expor e permitir que seja possível gerenciar e obter informações sobre os filmes via Web API.

Realizamos também o mapeamento entre as classes do modelo de domínio e as classes que recebem e enviam informações via Web API.

Observe que definimos o roteamento usando o atributo Route :  [Route("filmes")] e em cada método Action definimos o respectivo método HTTP (Get, Post, Delete, Put) com roteamento e caminhos URL:

Aqui temos que "{id}" é uma variável de espaço reservado para a ID do filme quando Update e Delete foram chamados;

Quando Get for invocado, ele atribui o valor "{id}" na URL ao parâmetro id do método e usa Name = "GetFilme" para criar uma rota nomeada que permite ao aplicativo criar um link HTTP usando o nome da rota.

Agora é só alegria...

Na próxima parte do artigo vamos testar as operações CRUD da nossa Web API usando o Postman.

"E estava ali um homem que, havia trinta e oito anos, se achava enfermo.Jesus disse-lhe: Levanta-te, toma o teu leito, e anda.Logo aquele homem ficou são; e tomou o seu leito, e andava. E aquele dia era sábado."
 João 5:5-9

Veja os Destaques e novidades do SUPER DVD Visual Basic (sempre atualizado) : clique e confira !

Quer migrar para o VB .NET ?

Quer aprender C# ??

Quer aprender os conceitos da Programação Orientada a objetos ?

Quer aprender o gerar relatórios com o ReportViewer no VS 2013 ?

  Gostou ?   Compartilhe no Facebook   Compartilhe no Twitter

Referências:

José Carlos Macoratti