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:

            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

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