Acessando Dados com .NET Core – Preparando o Ambiente

Este artigo é parte da série:

Criando Aplicação Completa REST API Utilizando C#,Visual Studio e .NET Core

De forma simples e direta ao código, como criar e publicar um REST API com .NET Core desde a criação do código até a publicação e configuração de sevidores.

Para esta etapa do projeto, vamos criar um novo controller, chamado “DadosController” na pasta “Controllers”. Atente-se ao detalhe que é uma “API Controlller” e não “MVC Controller” conforme vem no padrão.

A rotina que fizemos para o código “BasicoAPIController” possui todas a operações de CRUD (Create, Retrieve, Update, Delete) sendo executadas contra um listagem interna, em memória.

Com o propósito de nos prepararmos para os próximos exercícios, o que vamos fazer agora é copiar todos os métodos daquela classe para uma nova classe chamada “DadosController” e remover os conteúdos de todos os métodos, para então escrever novos conteúdos, desta vez realizando as operações de CRUD contra um banco de dados.

Esse controller “DadosController” não vai fazer nada. Neste momento vai ser apenas um esqueleto para escrevermos os métodos de acesso a dados que virão nos próximos exercícios. Por isso vamos deixar propositalmente os conteúdos dos métodos vazios.

Alguns cuidados que foram tomados ao copiar e colar o código:

Trocar o nome em [Route].
Trocar os nomes nos métodos, para evitar o conflito com a classe existente. Todos os métodos ganharam um “-Dados” ao final de seus nomes.
Inserir retorno em todos os métodos, nem que seja “BadRequest” para que este código vazio não apresente erro.

using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Configuration;
using Treino_REST_02.Models;

namespace Treino_REST_02.Controllers
{
    /// <summary>
    /// Esqueleto para realizar operações CRUD.
    /// </summary>
    [Route("api/Dados")]
    [ApiController]
    public class DadosController : ControllerBase
    {

        IConfiguration Config;
        public List<UF> UFs = new List<UF>();

        /// <summary>
        /// Construtor inicia objeto Config
        /// </summary>
        /// <param name="_config"></param>
        public DadosController(IConfiguration _config) 
        {
            this.Config = _config;
        }

        /// <summary>
        /// Relação de todas as UFs com suas capitais
        /// </summary>
        /// <returns></returns>
        [HttpGet(Name = "ListaUF-Dados")]
        [ProducesResponseType(StatusCodes.Status200OK)]
        public ActionResult<IEnumerable<UF>> ListaUF()
        {
            return Ok(UFs);
        }

        /// <summary>
        /// Mostra os dados de uma UF específica
        /// </summary>
        /// <remarks>
        /// Caso o id não exista, retorna 404 Not Found. Caso id seja zero retorna Bad Request.
        /// </remarks>
        /// <param name="IdUF">Id da UF que será mostrada</param>
        /// <returns>Um JSON contendo os dados da UF selecionada.</returns>
        [HttpGet("{IdUF:int}", Name = "MostraUF-Dados")]
        [ProducesResponseType(200)]
        [ProducesResponseType(StatusCodes.Status400BadRequest)]
        [ProducesResponseType(StatusCodes.Status404NotFound)]
        public ActionResult<UF> MostraUF(int IdUF)
        {
            return BadRequest();
        }

        /// <summary>
        /// Adiciona uma nova UF à lista
        /// </summary>
        /// <param name="NovaUF"></param>
        /// <returns></returns>
        [HttpPost(Name = "Adiciona-Dados")]
        [ProducesResponseType(StatusCodes.Status200OK)]
        public ActionResult<IEnumerable<UF>> AdicionaUF(UF NovaUF)
        {
            return ListaUF();
        }

        /// <summary>
        /// Altera todos os dados de uma UF baseado em um id
        /// </summary>
        /// <param name="IdUF">Id da UF que será alterada</param>
        /// <param name="NomeUF">Novo nome (sigla) da UF</param>
        /// <param name="CapitalUF">Novo nome da capital</param>
        /// <returns></returns>
        [HttpPut(Name = "Altera-Dados")]
        [ProducesResponseType(StatusCodes.Status200OK)]
        public ActionResult<IEnumerable<UF>> AtualizaUF(int IdUF, string NomeUF, string CapitalUF)
        {
            return ListaUF();
        }

        /// <summary>
        /// Muda apenas a capital de uma UF baseado no nome da UF
        /// </summary>
        /// <param name="NomeUF">Nome da UF (sigla)</param>
        /// <param name="NovaCapital">Nome da nova capital</param>
        /// <returns></returns>
        [HttpPatch(Name = "MudaCapital-Dados")]
        [ProducesResponseType(StatusCodes.Status200OK)]
        public ActionResult<IEnumerable<UF>> MudaCapital(string NomeUF, string NovaCapital)
        {
            return ListaUF();
        }

        /// <summary>
        /// Elimina uma UF baseado no id
        /// </summary>
        /// <param name="DelId">Id da UF que será eliminada</param>
        /// <returns></returns>
        [HttpDelete(Name = "EliminaUF-Dados")]
        [ProducesResponseType(StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status400BadRequest)]
        [ProducesResponseType(StatusCodes.Status404NotFound)]
        public ActionResult<IEnumerable<UF>> EliminaUF(int DelId)
        {
            return ListaUF();
        }
    }
}

Vamos também incrementar a classe “UF.cs” para incluir as “Annotations”. Elas serão importantes depois para as operações envolvendo bancos de dados.

using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;

namespace Treino_REST_02.Models
{
    [Table("Capitais")]
    public class UF
    {
        [Required] 
        [Column("Id",TypeName = "int")]
        [Key] [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
        public int Id { get; set; }

        [Required] 
        [Column("UF", TypeName = "char")] 
        [MaxLength(2)]
        public required string Nome { get; set; }

        [Required] 
        [Column("Capital",TypeName = "varchar")] 
        [MaxLength(50)]
        public string? Capital { get; set; }

    }
}

Tendo feito essas operações, agora temos um esqueleto de operações CRUD que, até o momento ainda não faz nada, mas já responde no Swagger.

O próximo passo, antes de efetivamente começar a implementar o acesso a dados tanto com ADO.NET quanto com Entity Framework, vamos aprender como configurar a string de conexão.