Este artigo é parte da série:
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 é instalá-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:
No SQL Server, crie um banco de dados. A tabela que iremos trabalhar será criada automaticamente pelo Entity Framework. Para fins deste exercício, o banco de dados vai se chamar “Treino01”. Se você está vindo do exercício anterior “Acessando Dados com ADO.NET no .NET Core”, o banco de dados já estará criado.
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();
}
}
}Execute o teste com o Swagger e perceba que agora o programa faz toda a manipulação de dados utilizando o Entity Framework.
Com isso concluímos toda a parte de programação da nossa API. Os próximos tópicos serão referentes à infraestrutura de execução do programa.
