Utilizando o Entity Framework Core 1 no ASP.NET MVC

Fala Galera,

Neste post iremos demonstrar como utilizar o EF Core 1 no ASP.NET MVC.

Conforme falado no último post 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 MVC porém o EF Core 1 pode ser utilizado em qual projeto .NET.

Também utilizaremos um banco de dados SQL SERVER para que entendimento seja mais fácil.

O objetivo é criar um CRUD (CREATE, RETREAVE, UPDATE, DELETE) básico assim poderemos focar nas novas funcionalidades do EF Core 1.

Os pré-requisitos para utilização do EF Core 1 são:

• Visual Studio 2015 ou Visual Studio 2013
• 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.1

Escolha ASP.NET Web Application depois iremos selecionar a opção MVC e clique em OK

Adicionando o EF Core 1 ao projeto

Com o projeto MVC criado devemos agora adicionar os pacotes do EF Core 1.

O EF Core 1 está disponível via NuGet então para isso basta digitar o comando Install-Package EntityFramework.Core -Pre no Package Manager Console

Para exibir o Package Manager Console vá em Tools -> NuGet Package Manager -> 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 EntityFramework.MicrosoftSqlServer –Pre  no Package Manager Console

Para saber a lista de Database Providers disponíveis clique aqui

Adicionando Migrations do EF Core 1 ao Projeto

Para adicionar os Migrations do EF Core 1 devemos executar o comando Install-Package EntityFramework.Commands –Pre 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 Int32 Id { get; set; }
    public String Title { get; set; }
    public string Content { get; set; }
    public string Author { get; set; }
    public List<Comment> Comments { get; set; }
}

 

Criando o Contexto

Vamos criar nosso contexto, ele será responsável por gerenciar as operações do banco de dados

Vamos criar uma classe chamada Context conforme código abaixo:

public class Context : DbContext
   {
       public DbSet<Post> Posts { get; set; }
       public DbSet<Comment> Comments { get; set; }

       protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
       {
           var connectionString = ConfigurationManager.ConnectionStrings["BlogConnection"].ToString();

           //Usando VS 2015 LocalDB - Data Source=(LocalDB)\MSSQLLocalDB;AttachDbFilename=|DataDirectory|\Blog.mdf;Integrated Security=True
           //Usando VS 2013 LocalDB - Data Source=(LocalDB)\v11.0;AttachDbFilename=|DataDirectory|\Blog.mdf;Integrated Security=True
           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

Dica: Os comandos de migração serão alterados na plataforma DNX (.NET Core 1) assim no futuro usaremos os seguintes comandos:

• dnx ef migrations add InitialSetup
• dnx ef database update

Veja as novas opções do EF Core 1 na figura abaixo:

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
   {
       Context context = new Context();

       public ActionResult List(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, Microsoft.Data.Entity.GraphBehavior.SingleObject);
           context.SaveChanges();

           return RedirectToAction("List", 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 = Microsoft.Data.Entity.EntityState.Modified;
           context.SaveChanges();

           return RedirectToAction("List", 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("List", 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 EF Core 1 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 EF Core 1 está disponibilizado no GitHub através deste link

Abs e até a próxima.