Acessando Dados com Entity Framework no .NET Core

Este artigo é parte da série:

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

Todos os passos de forma simples e direta sobre como criar e publicar um REST API com .NET Core.

Em primeiro lugar, tenha em mente que o .NET Core não traz a biblioteca Entity Framework instalada por padrão. Então, primeiro passo é intalá-la a partir do NuGet.

Instale o pacote “Microsoft.EntityFrameworkCore.Tools” e, como estamos trabalhando com SQL Server, instale também “Microsoft.EntityFrameworkCore.SqlServer”. Supostamente, seria necesário instalar o pacote “Microsoft.EntityFrameworkCore” também, mas isso não é necessário porque ele já instala junto com o “Microsoft.EntityFrameworkCore.SqlServer”.

Caso você tenha chegado nesta página agora, saiba que este exercício é uma continuação, então para entender o que está acontecendo, volte para o exercício anterior:

Acessando Dados com .NET Core – Preparando o Ambiente

Como acessar bancos de dados utilizando a linguagem C# no .NET Core.

No SQL Server, crie um banco de dados. A tabela que iremos trabalhar será criada automaticamente pelo Entity Framework.

Para manipular o banco de dados, o EF (Entity Framework) precisa de uma classe baseada em DbContext. Vamos adicioná-la na pasta “Models” com o nome “UFdbContext.cs”. Neste primeiro momento, iremos apenas criar o objeto “UFLista” do tipo DbSet manipulando objetos da classe UF.

    public class UFdbContext : DbContext
    {
        public DbSet<UF> UFs { get; set; }
    }

E para que o DbContext UFs encontre o banco de dados, vamos informar a string de conexão sobrescrevendo o método OnConfiguring da DbContext:

protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
    base.OnConfiguring(optionsBuilder);
    optionsBuilder.UseSqlServer(String de Conexão);
}

No final, a classe “UFdbContext” fica assim:

using Microsoft.EntityFrameworkCore;

namespace Treino_REST_02.Models
{
    public class UFdbContext : DbContext
    {
        public DbSet<UF> UFs { get; set; }

        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
        {
            base.OnConfiguring(optionsBuilder);
            var cnStr = new ConfigurationBuilder().AddJsonFile("appsettings.json").Build().GetSection("ConnectionStrings")["cnMain"];
            optionsBuilder.UseSqlServer(cnStr);
        }
    }
}

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

Agora vamos copiar para “EFMetodoController” toda a estrutura que fizemos em “DadosController” e substituir todas as designações “Dados” para “EF” para evitar conflito na hora de compilar o programa.

Segue o código já com os métodos implementados:

using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using Treino_REST_02.Models;

namespace Treino_REST_02.Controllers
{
    /// <summary>
    /// Exemplo de operações CRUD com Entity Framework
    /// </summary>
    [Route("api/[controller]")]
    [ApiController]
    public class EFMetodoController : ControllerBase
    {
        /// <summary>
        /// Config manipula as configurações em appsettings.json
        /// </summary>
        public readonly IConfiguration Config;

        /// <summary>
        /// UFs é uma lista de objetos do tipo UF
        /// </summary>
        public List<UF> UFs = new List<UF>();
        UFdbContext dbUF = new UFdbContext();

        /// <summary>
        /// Construtor da classe
        /// </summary>
        /// <param name="_config"></param>
        public EFMetodoController(IConfiguration _config) 
        {
            Config = _config;

            dbUF.Database.EnsureCreated();

            if(dbUF.UFs.Count() == 0)
            {
                var UF1 = new UF() { Nome = "AM", Capital = "Manaus" };
                var UF2 = new UF() { Nome = "PA", Capital = "Belém" };
                var UF3 = new UF() { Nome = "PI", Capital = "Teresina" };
                dbUF.UFs.Add(UF1);
                dbUF.UFs.Add(UF2);
                dbUF.UFs.Add(UF3);
                dbUF.SaveChanges();

            }
        }

        /// <summary>
        /// Lista todas as UFs do banco de dados
        /// </summary>
        /// <returns></returns>
        [HttpGet(Name = "ListaUF-EF")]
        [ProducesResponseType(StatusCodes.Status200OK)]
        public ActionResult<IEnumerable<UF>> ListaUF()
        {
            return Ok(dbUF.UFs.ToList());
        }

        /// <summary>
        /// Mostra dados de uma UF baseado no id
        /// </summary>
        /// <param name="IdUF">Id da UF</param>
        /// <returns></returns>
        [HttpGet("{IdUF:int}", Name = "MostraUF-EF")]
        [ProducesResponseType(200)]
        [ProducesResponseType(StatusCodes.Status400BadRequest)]
        [ProducesResponseType(StatusCodes.Status404NotFound)]
        public ActionResult<UF> MostraUF(int IdUF)
        {
            var res = dbUF.UFs.Where(x => x.Id == IdUF).ToList();
            if (res == null || res.Count ==0)
            {
                return NotFound();
            }
            UF ret = res[0];
            return Ok(ret);
        }

        /// <summary>
        /// Adiciona uma nova UF ao banco de dados
        /// </summary>
        /// <param name="NovaUF"></param>
        /// <returns></returns>
        [HttpPost(Name = "Adiciona-EF")]
        [ProducesResponseType(StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status400BadRequest)]
        [ProducesResponseType(StatusCodes.Status404NotFound)]
        public ActionResult<IEnumerable<UF>> AdicionaUF(UF NovaUF)
        {
            if (NovaUF.Id > 0)
            {
                return AtualizaUF(NovaUF.Id, NovaUF.Nome, NovaUF.Capital);
            }
            dbUF.UFs.Add(NovaUF);
            dbUF.SaveChanges();
            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-EF")]
        [ProducesResponseType(StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status400BadRequest)]
        [ProducesResponseType(StatusCodes.Status404NotFound)]
        public ActionResult<IEnumerable<UF>> AtualizaUF(int IdUF, string NomeUF, string CapitalUF)
        {
            var res = dbUF.UFs.Where(x => x.Id == IdUF).ToList();
            if (res == null || res.Count == 0)
            {
                return NotFound();
            }
            UF ret = res[0];
            ret.Nome = NomeUF;
            ret.Capital = CapitalUF;
            dbUF.UFs.Update(ret);
            dbUF.SaveChanges();
            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-EF")]
        [ProducesResponseType(StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status400BadRequest)]
        [ProducesResponseType(StatusCodes.Status404NotFound)]
        public ActionResult<IEnumerable<UF>> MudaCapital(string NomeUF, string NovaCapital)
        {
            var res = dbUF.UFs.Where(x => x.Nome == NomeUF).ToList();
            if (res == null || res.Count == 0)
            {
                return NotFound();
            }
            foreach (UF uf in res)
            {
                uf.Capital = NovaCapital;
                dbUF.UFs.Update(uf);
            }
            dbUF.SaveChanges();
            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-EF")]
        [ProducesResponseType(StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status400BadRequest)]
        [ProducesResponseType(StatusCodes.Status404NotFound)]
        public ActionResult<IEnumerable<UF>> EliminaUF(int DelId)
        {
            var res = dbUF.UFs.Where(x => x.Id == DelId).ToList();
            if (res == null || res.Count == 0)
            {
                return NotFound();
            }
            UF ret = res[0];
            dbUF.UFs.Remove(ret);
            dbUF.SaveChanges();
            return ListaUF();
        }
    }
}