EF Core -  Iniciando com o Entity Framework Core - II
 Neste artigo vamos criar uma aplicação console que realiza as operações básicas de acesso a dados contra o banco de dados SQLite usando o EF Core. (Veja as referências para consultar o artigo original)

Continuando o artigo anterior vamos agora criar uma aplicação console definindo o modelo e usando o EF Core Migrations para criar o banco de dados a partir do modelo.

Nota: Se você não sabe o que o Migrations leia o artigoEntity Framework - Usando o recurso Code First - Migrations

Recurso utilizados :

Alerta :

O .NET Core SDK 1.1  não suporta mais o project.json nem o VS 2015. Logo, recomenda-se migrar de project.json para .csproj e usar o VS 2017.

Criando o projeto Console

Para criar o nosso projeto não vamos usar o Visual Studio. Vamos usar um terminal de comandos ou a janela do console e realizar as seguintes tarefas :

A NET Core CLI (Net Core Command Line Interface) é uma nova ferramenta multiplataforma para desenvolvimento de aplicativos em .NET Core. A CLI é a base na qual outras ferramentas de nível superior, como IDEs (Ambientes de Desenvolvimento Integrado), editores e orquestradores de build, se baseiam.

Os comandos mais usados são:

  • dotnet new - Exibe os templates disponíveis;
  • dotnet new <nome_template> -n <nome_projeto> - Cria o projeto com base no nome do template com o nome informado;
  • dotnet migrate - Migra os projetos que usam o arquivo project.json para o formato .csproj;
  • dotnet restore - Restaura as dependências e os pacotes do projeto;
  • dotnet build - Constroi o projeto;
  • dotnet run - Executa o projeto;

 

Abra um janela de prompt de comandos (se você não sabe como fazer isso leia o artigo Usando o terminal de linha de comando (prompt de comandos)

A seguir digite os seguintes comandos na janela:

  1. posicione-se na raiz: cd\
  2. crie a pasta consoleAppSQLite : md consoleAppSQLite
  3. posicione-se na pasta criada: cd consoleAppSQLite
  4. crie o projeto console: dotnet new console

Ao final do processo você verá os arquivos Program.cs e consoleAppSQLite.csproj criados na pasta consoleAppSQLite:

Observe que não temos mais o project.json mas sim o arquivo de projeto .csproj.

Instalando o Entity Framework Core

Vamos agora instalar o EF Core e para fazer isso temos que alterar o arquivo consoleAppSQLite.csproj.

Para isso vamos usar o Visual Studio Code. Para abrir o projeto no VS Code basta digitar na pasta do projeto o comando :  code .

A seguir veremos o VS Code abrir e exibir projeto criado.

Selecione o arquivo consoleAppSQLite.csproj e inclua as linhas para instalar o EF Core. (linhas destacadas em azul):

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>netcoreapp1.1</TargetFramework>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="1.1.1" />
    <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="1.1.1" PrivateAssets="All" />
  </ItemGroup>
  <ItemGroup>
    <DotNetCliToolReference Include="Microsoft.EntityFrameworkCore.Tools.DotNet" Version="1.0.0" />
  </ItemGroup>
</Project>

O que vale a pena destacar :

1- As versões utilizadas são as versões atuais na data que o artigo foi escrito; (abril de 2017)

2- Uma referência de pacote particular (PrivateAssets = "All") significa que essa dependência é local para o projeto atual;

Para instalar os pacotes referenciados vamos executar o comando  :  dotnet restore

Ao final do processo será criada a pasta obj no projeto contendo as dependências e as referências do projeto.

Criando o modelo

Vamos agora criar o modelo em nosso projeto.

Para isso crie o arquivo Model.cs na pasta consoleAppSQLite usando o VS Code e a seguir inclua o código abaixo neste arquivo:

using Microsoft.EntityFrameworkCore;
using System.Collections.Generic;
namespace consoleAppSQLite
{
 public class BlogContext : DbContext
    {
        public DbSet<Blog> Blogs { get; set; }
        public DbSet<Post> Posts { get; set; }
        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
        {
            optionsBuilder.UseSqlite("Data Source=blog.db");
        }
    }
    public class Blog
    {
        public int BlogId { get; set; }
        public string Url { get; set; }
        public List<Post> Posts { get; set; }
    }
    public class Post
    {
        public int PostId { get; set; }
        public string Titulo { get; set; }
        public string Conteudo { get; set; }
        public int BlogId { get; set; }
        public Blog Blog { get; set; }
    }
}

Alerta :  Em um aplicativo real você colocaria cada classe em um arquivo separado e colocaria a string de conexão em um arquivo de configuração. Para manter o tutorial simples, estamos colocando tudo em um arquivo.

Criando o banco de dados

Agora que já criamos o nosso modelo podemos criar o banco de dados a partir do modelo e vamos fazer isso usando o Migrations.

Execute os seguintes comandos no prompt de comando:

Atenção,  ao usar caminhos relativos com o SQLite, o caminho será relativo ao assembly principal do aplicativo.

Neste exemplo, o binário principal é bin/Debug/ netcoreapp1.1/ConsoleAppSQLite.dll, portanto, o banco de dados SQLite estará localizado em bin/Debug/netcoreapp1.1/blog.db.

Usando o Modelo

Vamos agora usar o modelo criado em nosso projeto com os recursos do EF Core.

Abra o arquivo Program.cs e inclua o código abaixo :

using System;
namespace consoleAppSQLite
{
    class Program
    {
        static void Main(string[] args)
        {
            using (var db = new BlogContext())
            {
                db.Blogs.Add(new Blog { Url = "http://blogs.msdn.com/adonet" });
                db.Blogs.Add(new Blog { Url = "http://macoratti.net/aspnet" });
                db.Blogs.Add(new Blog { Url = "http://microsoft.msdn/vbnet" });
                var contador = db.SaveChanges();
                Console.WriteLine("{0} registros salvos no banco de dados ", contador);
                Console.WriteLine();
                Console.WriteLine("Todos os blogs no banco de dados:");

                foreach (var blog in db.Blogs)
                {
                    Console.WriteLine(" - {0}", blog.Url);
                }
            }
        }
    }
}

Testando a aplicação

Para testar a aplicação digite o seguinte comando no prompt de comandos :  dotnet run

Ao final do processamento teremos o seguinte resultado:

E assim acabamos de criar uma aplicação Console usando o Entity Framework Core onde criamos um modelo e criamos o banco de dados a partir deste modelo e a seguir incluímos dados e acessamos as informações do banco de dados.

E, fizemos tudo isso sem usar o Visual Studio.

Se você fizer alterações em seu modelo, use o comando dotnet ef migrations add para alterar uma nova migração e para efetuar as alterações de esquema correspondentes no banco de dados. Após isso use o comando dotnet ef database update para aplicar as alterações ao banco de dados.

O EF usa uma tabela __EFMigrationsHistory no banco de dados para acompanhar quais migrações já foram aplicadas ao banco de dados.

O SQLite não suporta todas as migrações (alterações de esquema) devido a limitações no SQLite.

Pegue o projeto completo aqui : consoleAppSQLite.zip

(Disse Jesus) "Quem ama a sua vida perdê-la-á, e quem neste mundo odeia a sua vida, guardá-la-á para a vida eterna."
João 12:25
Veja os Destaques e novidades do SUPER DVD Visual Basic (sempre atualizado) : clique e confira !

Quer migrar para o VB .NET ?

Quer aprender C# ??

Quer aprender os conceitos da Programação Orientada a objetos ?

Quer aprender o gerar relatórios com o ReportViewer no VS 2013 ?

  Gostou ?   Compartilhe no Facebook   Compartilhe no Twitter

Referências:


José Carlos Macoratti