Criando aplicações utilizando ASP.NET Core MVC com Entity Framework Core

4 jul

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 downloadpodemos utilizar outro Visual Studio porém o .NET Framework deverá ser no mínimo o 4.5.

AspNetCore

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.

AspNetCore2

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

AspNetCore4

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.

FinalCore1

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.

Deixe uma resposta

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *