Entity Framework Core - Usando o banco de dados SQLite

 Neste artigo vamos criar uma aplicação ASP .NET Core usando o Entity Framework Core e acessando o SQLite e realizando o CRUD básico.

O Entity Framework Core (EF Core) é uma versão leve, extensível e multiplataforma do Entity Framework. O EF Core introduz muitas melhorias e novos recursos quando comparado com o EF6.x.  O EF Core mantém a experiência do desenvolvedor do EF6.x e a maioria das APIs de alto nível permanecem as mesmas, então o EF Core vai te parecer muito familiar se você conhece o Entity Framework 6.x.

Ao mesmo tempo, o EF Core é construído sobre um conjunto completamente novo de componentes principais. Isso significa que o EF Core não herda automaticamente todos os recursos do EF6.x. Alguns desses recursos serão exibidos em lançamentos futuros (como o lazy loading e a resiliência de conexão), outros recursos menos usados não serão implementados no EF Core.  O novo núcleo, extensível e leve também permitiu adicionar alguns recursos ao EF Core que não serão implementados no EF6.x.

Para acompanhar este artigo você precisa ter instalado o Visual Studio Community 2017 com os seguintes workloads(cargas de trabalho) instalados:

Criando o projeto web Exemplo :  Contatos

A aplicação exemplo que vamos construir nesse artigo é um simples site para gerenciar as informações de contatos onde iremos focar na utilização do Entity Framework Core com o SQLite.

Vamos iniciar criando uma aplicação ASP .NET Core MVC Web Application.

Abra no VS Community 2017 e no menu File clique em New Project;

A seguir selecione o template Visual C# -> .NET Core e marque ASP .NET Core Web Application (.NET Core);

Dessa forma estamos criando uma aplicação web (MVC com views e controllers) usando o framework .NET Core.

Informe o nome Contatos (ou outro a seu gosto) e clique no botão OK;

Na próxima janela escolha a versão ASP .NET Core 1.1 e marque o template Web Application sem autenticação e clique no botão OK;

Temos assim uma aplicação funcional, na verdade , um simples projeto inicial, que será o nosso ponto de partida.

Adicionando o suporte para o Entity Framework Core via Nuget

Vamos adicionar o suporte ao EF Core em nosso projeto e instalar o provedor do banco de dados que vamos usar. No exemplo deste artigo vamos instalar o provedor SQLite : Microsoft.EntityFrameworkCore.Sqlite.

Para instalar esse via menu Tools e e clicar em Nuget Package Manager e a seguir em Manage Nuget Packages for Solution;

Vamos instalar os pacotes :

Estes pacote e suas dependências ( Microsoft.EntityFrameworkCore e Microsoft.EntityFrameworkCore.Relational ) fornecem o suporte em tempo de execução ao EF e as ferramentas de design para o SQLite.

Vamos instalar também o pacote Microsoft.EnityFrameworkCore.Tools no projeto para ter acesso ao Migrations :

Nota:  O EF para no .NET Core não possui todas as funcionalidades do EF 6. (lazy loading não esta suportado ainda)

Criando o nosso modelo de dados

Agora que temos o suporte ao EF Core vamos criar as classes das entidades para a nossa aplicação.

Como nossa aplicação é bem simples e vai gerenciar informações de contatos ela vai ter apenas uma entidade chamada Contato.

Vamos agora criar  a classe que representa a nossa entidade.

Criando a entidade Contato

Vamos criar uma pasta chamada "Models" no projeto para nesta pasta definir o modelo de entidades.

Nota: Você pode colocar classes do modelo em qualquer lugar em seu projeto, mas a pasta Models é usada por convenção.

Na janela Solution Explorer, clique com o botão direito do mouse no projeto e selecione Add -> New Folder e informe o nome Models.

As classes são criadas na pasta Models clicando com o botão direito sobre a pasta, selecionando Add -> Class e a seguir informando o nome da classe.

Vamos iniciar criando o arquivo Contato.cs e nele vamos definir a classe Contato conforme abaixo:

namespace Contatos.Models
{
    public class Contato
    {
        public int Id { get; set; }
        public string Nome { get; set; }
        public string Endereco { get; set; }
        public string Cidade { get; set; }
        public string Estado { get; set; }
        public string Cep { get; set; }
        public string Fone { get; set; }
        public string Email { get; set; }
    }
}

A propriedade Id será a coluna de chave primária da tabela de banco de dados que corresponde a essa classe. Por padrão, o Entity Framework interpreta uma propriedade que é chamada de ID ou nome_classeID como sendo a chave primária.(Podemos alterar esse comportamento com annotations)

Nota : O Entity Framework por padrão adota algumas convenções (Conventions) que ele usa para realizar algumas operações.

Criando a classe de contexto do Banco de dados

O Entity Framework permite consultar, inserir, atualizar e excluir dados, usando objetos CLR(Common Language Runtime) conhecidos como entidades; ele mapeia as entidades e relacionamentos que são definidos no seu modelo de entidades para um banco de dados e fornece facilidades para realizar as seguintes tarefas:

1- Materializar dados retornados do banco de dados como objetos de entidade;
2- Controlar as alterações que foram feitas nos objetos;
3- Lidar com concorrência;
4- Propagar as alterações feitas nos objetos de volta ao banco de dados;
5- Vincular objetos a controles.


A principal classe responsável pela interação com os objetos de dados é a classe System.Data.Entity.DbContext (muitas vezes referida como o contexto).

Essa classe de contexto administra os objetos entidades durante o tempo de execução, o que inclui preencher objetos com dados de um banco de dados, controlar alterações, e persistir dados para o banco de dados.

A maneira recomendada para trabalhar com o contexto é definir uma classe que deriva de DbContext e expõe as propriedades de DbSet que representam as coleções das entidades especificadas no contexto.

Essa classe é chamada de classe de contexto do banco de dados e coordena a funcionalidade do Entity Framework para um dado modelo de dados. No código dessa classe você especifica quais entidades estão incluídas no modelo de dados. Você também pode personalizar determinado comportamento do Entity Framework. Neste projeto, a nossa classe de contexto será chamada ContatoContexto.

Para simplificar eu vou criar essa classe na pasta Models. Então crie o arquivo ContatoContexto.cs na pasta Models e a seguir inclua o código abaixo na classe ContatoContexto:

using Microsoft.EntityFrameworkCore;
namespace Contatos.Models
{
    public class ContatoContexto : DbContext
    {
        public ContatoContexto(DbContextOptions<ContatoContexto> options) : base(options)
        {
        }
        public DbSet<Contato> Contatos { get; set; }
        protected override void OnModelCreating(ModelBuilder builder)
        {
               builder.Entity<Contato>().HasKey(m => m.Id);
               base.OnModelCreating(builder);
        }
    }
}

Este código cria uma propriedade DbSet para cada a entidade Contato. Na terminologia Entity Framework, um conjunto de entidades corresponde a uma tabela de banco de dados e uma entidade corresponde a uma linha na tabela.

Registrando o contexto com injeção de dependência

A ASP.NET Core implementa a injeção de dependência por padrão. Os serviços (como o contexto de banco de dados do EF) são registrados com injeção de dependência durante a inicialização do aplicativo. Componentes que requerem esses serviços (como controladores MVC) fornecem esses serviços através de parâmetros do construtor. Mais adiante iremos definir no construtor do controlador a instância do contexto.

Para registrar o nosso contexto ContatoContexto como um serviço, abra o arquivo Startup.cs e adicione as linhas realçadas ao método ConfigureServices:

using Microsoft.EntityFrameworkCore;
...
....

    
  // This method gets called by the runtime. Use this method to add services to the container.
        public void ConfigureServices(IServiceCollection services)
        {
            var connection = Configuration["ConexaoSqlite:SqliteConnectionString"];
            services.AddDbContext<ContatoContexto>(options =>
                options.UseSqlite(connection)
            );
            // Add framework services.
            services.AddMvc();
        }
....

O nome da string de conexão é passada para o contexto pela chamada do método no objeto DbContextOptionsBuilder. Para o desenvolvimento local a ASP .NET Core obtém a string de conexão do arquivo appsettings.json.

Vamos então abrir o arquivo appsettings.json e adicionar a string de conexão conforme mostrado a seguir:

{
  "ConexaoSqlite": {
    "SqliteConnectionString": "Data Source=Contatos.db"
  },
  "Logging": {
    "IncludeScopes": false,
    "LogLevel": {
      "Default": "Warning"
    }
  }
}

A string de conexão especifica um banco de dados identificado por Contatos.db.

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.

Abra uma  janela console e posicione-se na pasta do projeto que no nosso exemplo foi criado na pasta : c:\_aspncore\contatos\contatos (verifique no seu ambiente qual o caminho usado)

A seguir execute os seguintes comandos no prompt de comando:

  • dotnet ef migrations add TesteMigration   - para suportar a migração e criar o conjunto inicial de tabelas para o modelo;

  • dotnet ef database update - para aplicar a migração ao banco de dados;

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/Contatos.dll, portanto, o banco de dados SQLite estará localizado em bin/Debug/netcoreapp1.1/Contatos.db.

Dessa forma

Criando um novo Controller e suas Views

Se você não sabe o que é um Controller então pode ler os seguintes artigos  :

Os Controllers ou Controladores são os componentes que lidam com a interação do usuário, trabalham com o modelo e, finalmente, selecionam uma exibição de renderização que mostra essa interface ao usuário. Por padrão os controladores são colocados na pasta Controllers da solução.

A criação automática dos métodos Actions para realizar o CRUD e as Views é conhecida como Scaffolding. O Scaffolding irá criar automaticamente os métodos Action e as Views, e, quando você precisar personalizar o código gerado, você pode usar classes parciais ou você regenera o código quando as houver alterações.

Vamos iniciar criando um controlador em nosso projeto. Clique com o botão direito do mouse sobre a pasta Controllers, e a seguir clique em Add -> Controller;

Na janela Add MVC Dependencies selecione a opção - Minimal Dependencies e clique no botão Add;

O VS 2017 vai adicionar as dependências necessárias para montar o controller.

Após isso repita o procedimento e clique com o botão direito do mouse sobre a pasta Controllers, e a seguir clique em Add -> Controller;

Na janela Add Scaffold selecione a opção : MVC Controller with views, using Entity Framework :

Clique no botão Add.

Agora na janela Add Controller vamos fazer as seguintes definições :

Model Class :  Selecione Contato(Contatos.Models)

Data context class :  clique no botão + e selecione ContatoContexto(Contatos.Models) e clique no botão Add;

Ao clicar no botão Add, o mecanismo de Scaffolding do Visual Studio irá criar um arquivo ContatosController.cs, na pasta Controllers, e um conjunto de Views (arquivos .cshtml), na pasta /Views/Contatos, que funcionam com o controlador.

A figura abaixo mostra o resultado:

Note que o controlador toma o nosso contexto, EscolaContexto, como um parâmetro de construtor.

A injeção de dependência do contâiner ASP .NET Core vai cuidar de passar uma instância de ContatoContexto para o controlador porque isso foi configurado no arquivo Startup.cs, lembra... ?

O controlador contém um método Action Index que exibe todos os contatos existentes no banco de dados, ele obtém uma lista de contatos do conjunto de entidades Contatos lendo a propriedade Contatos da instância do contexto do banco de dados.

        // GET: Contatos
        public async Task<IActionResult> Index()
        {
            return View(await _context.Contatos.ToListAsync());
        }

Note que é retornado uma View, a view Index.cshtml, que exibe uma lista de Contatos em uma tabela: (Eu já traduzi os textos)

Antes de executar o projeto vamos alterar o arquivo Startup.cs alterando o controlador para Contatos conforme mostra a figura a seguir:

Executando o projeto iremos obter o seguinte resultado:

Inicialmente não temos nenhuma informação pois a tabela Contatos esta vazia. Clique no link - Criar Novo Contato - para inserir um novo contato:

Após informar os dados e clicar no botão Create vemos abaixo as informações do contato exibidas na página:

Criamos assim uma aplicação ASP .NET MVC para gerenciar informações de contatos usando a ASP .NET Core e o EntityFramework Core acessando o Sqlite.

Pegue o projeto completo aqui: Contatos.zip

Se dissermos que temos comunhão com ele (Jesus), e andarmos em trevas, mentimos, e não praticamos a verdade.
Mas, se andarmos na luz, como ele na luz está, temos comunhão uns com os outros, e o sangue de Jesus Cristo, seu Filho, nos purifica de todo o pecado.

1 João 1:6,7

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