Fala Galera,
Neste post iremos demonstrar como utilizar o Entity Framework Core no ASP.NET Core MVC.
Conforme falado no meu post o “Introdução ao Entity Framework Core”, o Entity Framework sofreu algumas mudanças para se adaptar ao novos desafios criado pela arquitetura .NET Core multiplataforma.
Não viu o post “Introdução ao Entity Framework Core 1”, clique aqui.
Vamos criar uma aplicação ASP.NET Core MVC utilizando o Entity Framework Core. Também utilizaremos um banco de dados SQL SERVER para que entendimento seja mais fácil.
O objetivo é criar um CRUD (CREATE, RETRIAVE, UPDATE, DELETE) básico assim poderemos focar nas novas funcionalidades do Entity Framework Core.
Os pré-requisitos para utilização do Entity Framework Core são:
- Visual Studio 2015 com o .Net Core Tools instalado
- Versão atualizada do NuGet Package Manager
- Versão atualizada do Windows Power Shell
Criando o projeto
Para criar nosso projeto ASP.NET MVC utilizaremos o Visual Studio Community 2015 (clique aqui para fazer o download) podemos utilizar outro Visual Studio porém o .NET Framework deverá ser no mínimo o 4.5.
Escolha ASP.NET Web Application depois iremos selecionar a opção Web Application e clique em OK
Adicionando o Entity Framwork Core ao projeto
Com o projeto MVC criado devemos agora adicionar os pacotes do EF Core 1.
O Entity Framework Core está disponível via NuGet então para isso basta digitar o comando Install-Package Microsoft.EntityFrameworkCore no Package Manager Console
Para exibir o Package Manager Console vá em Tools -> NuGet Package Manager -> Package Manager Console.
Adicionando Migrations do Entity Framework Core ao Projeto
Para adicionar os Migrations do Entity Framework Core devemos executar o comando Install-Package Microsoft.EntityFrameworkCore.Tools -Pre no Package Manager Console
Escolhendo o Database Provider
Nosso projeto utilizará o SQL SERVER para isso devemos instalar o provider correspondente executando o comando Install-Package Microsoft.EntityFrameworkCore.SqlServer no Package Manager Console
Criando o Modelo
Agora que estamos com todas as dependências instalada, vamos criar nossas Models. Primeiro vamos criar uma model de Comment conforme código abaixo:
public class Comment
{
public Int32 Id { get; set; }
public DateTime CreateDate { get; set; }
public String Text { get; set; }
public Int32 PostId { get; set; }
}
Depois vamos adicionar uma model de Post conforme código abaixo:
public class Post
{
public int Id { get; set; }
[Required]
public string Title { get; set; }
[Required]
public string Content { get; set; }
[Required]
public string Author { get; set; }
public List<Comment> Comments { get; set; }
}
Alterando o Startup
Devemos alterar o Startup.cs para que possamos acessar o arquivo de configuração appsettings.json, assim vamos criar um campo static para tonar o acesso a configurações do sistema mais fácil
public class Startup
{
private static IConfigurationRoot configuration;
public static IConfigurationRoot Configuration
{
get
{
return configuration;
}
}
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 void ConfigureServices(IServiceCollection services)
{
//Adicionando o Contexto na injeção de dependencia
services.AddDbContext<BlogContext>();
// Add framework services.
services.AddMvc();
}
public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)
{
loggerFactory.AddConsole(configuration.GetSection("Logging"));
loggerFactory.AddDebug();
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
app.UseBrowserLink();
}
else
{
app.UseExceptionHandler("/Home/Error");
}
app.UseStaticFiles();
app.UseMvc(routes =>
{
routes.MapRoute(
name: "default",
template: "{controller=Home}/{action=Index}/{id?}");
});
}
}
Como você podem notar também estamos utilizando a injeção de dependência do próprio ASP.NET Core no método ConfigureServices
Criando o Contexto
Vamos criar nosso contexto, ele será responsável por gerenciar as operações do banco de dados
Devemos primeiro adicionar o caminho de conexão com o banco de dados e para isso vamos abrir o arquivo appsettings.json e adicionar o seguinte objeto JSON
{
"ConnectionStrings": {
"BlogConnection": "Server=(localdb)\\mssqllocaldb;Database=BlogContext;Trusted_Connection=True;"
},
"Logging": {
"IncludeScopes": false,
"LogLevel": {
"Default": "Debug",
"System": "Information",
"Microsoft": "Information"
}
}
}
Agora vamos criar uma classe chamada Context conforme código abaixo:
public partial class BlogContext : DbContext
{
public DbSet<Post> Posts { get; set; }
public DbSet<Comment> Comments { get; set; }
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
var connectionString = Startup.Configuration["ConnectionStrings:BlogConnection"].ToString();
optionsBuilder.UseSqlServer(connectionString);
}
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
modelBuilder.Entity<Post>().HasKey(x => x.Id);
modelBuilder.Entity<Post>().Property(x => x.Id);
modelBuilder.Entity<Post>().Property(x => x.Title).IsRequired();
modelBuilder.Entity<Post>().Property(x => x.Content).IsRequired();
modelBuilder.Entity<Comment>().HasKey(x => x.Id);
modelBuilder.Entity<Comment>().Property(x => x.Id).UseSqlServerIdentityColumn();
modelBuilder.Entity<Comment>().Property(x => x.Text).IsRequired();
modelBuilder.Entity<Comment>().Property(x => x.CreateDate).ForSqlServerHasDefaultValue<DateTime>(DateTime.Now);
modelBuilder.Entity<Post>().HasMany<Comment>(x => x.Comments).WithOne();
}
}
Criando a base de dados:
Com o modelo e o contexto criado, vamos configurar nossa base de dados para isso iremos executar os comandos de migração no Package Manager Console:
- Add-Migration InitialSetup
- Update-Database
Inserindo um novo Post
Com a base de dados configurada e os modelos criados temos que criar a programação necessária para realizar a inserção dos novos objetos na base de dados
Vamos criar um controller chamado PostController e adicionar o código abaixo
public class PostController : Controller
{
BlogContext context;
public PostController(BlogContext context)
{
this.context = context;
}
public ActionResult Index(string message = "")
{
var models = this.context.Posts.ToList();
if (!String.IsNullOrEmpty(message))
ViewBag.Success = message;
return View(models);
}
public ActionResult Create()
{
return View();
}
[HttpPost]
public ActionResult Create(Post model)
{
if (!ModelState.IsValid)
return View(model);
context.Posts.Add(model);
context.SaveChanges();
return RedirectToAction("Index", new { message = "Post criado com sucesso!" });
}
public ActionResult Edit(int id)
{
var post = this.context.Posts.Where(x => x.Id == id).FirstOrDefault();
return View(post);
}
[HttpPost]
public ActionResult Edit(Post model)
{
if (!ModelState.IsValid)
return View(model);
context.Posts.Add(model);
context.Entry<Post>(model).State = EntityState.Modified;
context.SaveChanges();
return RedirectToAction("Index", new { message = "Post editado com sucesso!" });
}
public ActionResult Delete(int id)
{
var post = this.context.Posts.Where(x => x.Id == id).FirstOrDefault();
this.context.Posts.Remove(post);
this.context.SaveChanges();
return RedirectToAction("Index", new { message = "Post excluído com sucesso" });
}
}
Como podemos ver na imagem abaixo um novo post está sendo adicionado na nossa base de dados.
O Entity Framework Core passou por diversas mudanças internas para atender o cenário multiplataforma porém o uso em si para nós desenvolvedores não mudou tanto assim.
O que acharam ? Não deixem de comentar!
O código completo da utilização do Entity Framework Core está disponibilizado no GitHub através deste link
Abs e até a próxima.