ASP .NET Core - Acessando o PostgreSQL com Entity Framework Core

 Neste artigo vamos criar uma aplicação ASP .NET Core MVC que realiza o acesso a dados usando o Entity Framework Core e os recursos do Migrations para criar o banco de dados a partir do modelo.

Para acompanhar este artigo você precisa ter instalado o Visual Studio Community 2017 com os seguintes workloads e recursos instalados:

Se você não tem nenhuma noção sobre como funciona o padrão MVC e sua implementação ASP .NET sugiro que leia esses artigos :

Criando uma nova aplicação ASP .NET Core

Abra no VS 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);

Informe o nome APIFuncionarios 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;

Teremos o projeto ASP .NET Core criado contendo a estrutura básica, conforme figura abaixo, que será o nosso ponto de partida.

Definindo o banco de dados e a tabela no PostgreSQL

Como exemplo eu vou usar o PostgreSQL 9.6 onde criei o banco de dados Cadastro e a tabela funcionarios com a estrutura e dados exibidos abaixo no pgAdmin 4:

Vamos acessar esse banco de dados e a tabela funcionarios.

A string de conexão a ser definida para fazer o acesso será : Host=localhost;Port=5432;Pooling=true;Database=Cadastro;User Id=??;Password=??;

Instalando o Entity Framework Core 1.1 para o PostgreSQL

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 núcleo novo, extensível e leve também nos permitiu adicionar alguns recursos ao EF Core que não serão implementados no EF6.x.

Para instalar o Entity Framework em nosso projeto vamos usar a opção do menu Tools-> Nuget Package Manager ->  Package Manage Console.

Você deve instalar o pacote para o provedor do banco de dados EF Core que você deseja acessar. Os provedores atualmente disponíveis podem ser vistos neste link: Database Providers

Neste artigo vamos instalar o provider para o PostgreSQL.

Abra a janela do Console do Gerenciador de Pacotes clicando no menu Tools-> Nuget Package Manager ->  Package Manage Console.

A seguir digite o seguinte comando : Install-Package Npgsql.EntityFrameworkCore.PostgreSQL

Criando o Modelo de domínio : Funcionario

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

Vamos criar uma pasta chamada "Model" 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 Model.

As classes são criadas na pasta Model 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 Funcionario.cs e definir a classe Funcionario com o código abaixo:

using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
namespace APIFuncionarios.Model
{
    [Table("funcionarios")]
    public class Funcionario
    {
        [Key]
        public int id { get; set; }
        public string nome { get; set; }
        public int idade { get; set; }
        public string funcao { get; set; }
    }
}

A seguir, na pasta Model, vamos criar o classe FuncionarioContext com o código a seguir :

using Microsoft.EntityFrameworkCore;

namespace APIFuncionarios.Model
{
    public class FuncionarioContext : DbContext
    {
        public DbSet<Funcionario> Funcionarios { get; set; }

        public FuncionarioContext(DbContextOptions<FuncionarioContext> options) :
            base(options)
        {
        }
    }
}

Esta classe representa o contexto das nossas entidades mapeadas para as tabelas do banco de dados.

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.

Para que os controladores MVC da nossa aplicação utilizem o FuncionarioContext, vamos registrar o contexto como um serviço.

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

using Microsoft.EntityFrameworkCore;
using APIFuncionarios.Model;

...
....
        // This method gets called by the runtime. Use this method to add services to the container.
        public void ConfigureServices(IServiceCollection services)
        {
            // Add framework services.
            services.AddMvc();

             services.AddEntityFrameworkNpgsql()
             .AddDbContext<FuncionarioContext>(options => options.UseNpgsql(Configuration.GetConnectionString("FuncionariosDB")));
        }

....

Nota: Inclua a referência ao Microsoft.EntityFrameworkCore no arquivo.

A seguir precisamos definir a string de conexão identificada pelo nome 'FuncionariosDB' no arquivo appSettings.json :

{
  "ConnectionStrings": {
    "FuncionariosDB": "Host=localhost;Port=5432;Pooling=true;Database=Cadastro;User Id=??;Password=??;"
  },
  "Logging": {
    "IncludeScopes": false,
    "LogLevel": {
      "Default": "Warning"
    }
  }
}

Criando o Controller e as Views do projeto

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.

Antes de criar o controlador delete o arquivo HomeController.cs  existente da pasta Controllers pois vamos recriar este controlador com métodos Actions que acessam os dados no PostgreSQL.

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 Funcionario(APIFuncionarios.Model)

Data context class :  clique no botão + e selecione FuncionarioContext(APIFuncionarios.Model) e clique no botão Add;

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

Quando você executa o aplicativo e não fornece nenhum segmento de URL, o padrão usado será o controlador "Home" e o método "Index", especificado na linha template definida acima.

Execute o projeto teclando F5 e você verá a página abaixo exibida contendo as informações da nossa tabela funcionarios do PostgreSQL :



Clique no link Create New e inclua a os dados para um novo funcionário :

Ao clicar no botão Create teremos a exibição do funcionário criado conforme mostrado abaixo:

Examinando a tabela funcionarios no pgAdmin 4 constatamos que os dados foram incluídos :

E assim concluímos a criação da nossa aplicação ASP .NET MVC Core usando o Entity Framework Core para a partir do modelo e do contexto acessar e gerenciar os dados em nosso banco de dados.

Nota:  Da mesma forma poderíamos ter criado uma Web API na pasta Controllers para expor os dados dos funcionários.

Pegue o projeto completo aqui :  APIFuncionarios.zip

Considerai os corvos, que nem semeiam, nem segam, nem têm despensa nem celeiro, e Deus os alimenta; quanto mais valeis vós do que as aves? Lucas 12:24

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