ASP .NET Core - Acessando o banco de dados PostGreSQL no MacOS com VS for Mac - I

 Neste artigo vou mostrar como criar uma aplicação ASP .NET Core acessando um banco de dados PostgreSQL no Mac OS usando o Visual Studio for Mac.

Se você é um usuário Mac e pretende desenvolver aplicações para web e/ou aplicações para dispositivos móveis já tem a sua disposição a nova versão do Visual Studio for Mac.

O VS for Mac proporciona a mesma experiência do Visual Studio para os usuários Mac e permite desenvolver os seguintes tipos de projetos (estou listando apenas os principais):

O Visual Studio para Mac traz para o Mac a produtividade do desenvolvedor que você adora. A experiência foi feita meticulosamente para otimizar o fluxo de trabalho do desenvolver para o Mac.

Para provar isso vamos criar uma aplicação ASP .NET Core acessando o banco de dados PostGreSQL usando a nova versão do VS for Mac.

Para tornar o exemplo simples vamos gerenciar informações de Autores e Artigos.

Preparando o ambiente no Mac

Eu estou usando um iMac com o OS X El Capitan versão 10.11.6 com 4 GB e Intel Core 5.

Antes de iniciar, se você for um iniciante no ambiente Mac, sugiro que instale o homebrew no seu Mac com o seguinte comando (Caso tenha problemas, acesse o site oficial do homebrew):   

Abra um terminal e digite :  /usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"

Depois execute os seguintes comandos em seu terminal:

˜$ brew update
˜$ brew install openssl
˜$ brew link --force openssl

Pronto.

Agora vamos iniciar a preparação do ambiente do Mac para o .Net Core...

A primeira coisa a fazer e instalar os seguintes recursos no seu Mac :

  1. .NET Core SDK for OS X

Você deverá instalar o .NET Core 1.1 no macOS instalando o pacote .NET Core SDK. Esta é a versão mais estável.

Após instalar estes dois recursos no seu Mac abra um terminal e digite o comando : dotnet --version

Deverá ser exibido a versão do .Net Core instalada : 1.0.1

  1. Visual Studio for Mac

Intale  o Visual Studio for Mac para o desenvolvimento .NET Core no macOS. Os requisitos para sua instalação são:

É uma ferramenta que esta em preview e por isso pode não ser muito estável.

Instalando o PostgreSQL

Neste artigo eu vou acessar o PostGreSQL usando o Entity Framework Core.

A maneira mais fácil de instalar o PostgreSQL no OS X é usar o Homebrew. Como você já instalou o Homebrew então a instalação é feita com o seguinte comando:

$ brew install postgresql

Ao final do processo se tudo estiver correto o gerenciador do banco de dados estará instalado. Agora para executar o gerenciador como um serviço digite o seguinte comando:

$ brew services start postgresql

Se preferir executar em primeiro plano execute o comando :

$ postgresql -D /usr/local/var/postgres

Agora para pode usar o Migrations do Entity Framework você vai precisar de um usuário com a permissão createdb. Quando o PostgreSQL é instalado ele cria um perfil de super usuário automaticamente com os dados do seu login chamado postgres no perfil pg_roles.

Para executar consultas no PostgreSql você pode usar o terminal interativa psql. Vamos usar esse terminal e digitar o seguinte comando para criar a permissão createdb para o usuário postgres:

$ psql postgres -c "SELECT rolname, rolcreatedb::text FROM pg_roles"

Ao final desta etapa teremos o usuário postgres pronto para ser usado em nossa aplicação.

Instale também o PgAdmin 4 neste link - https://www.pgadmin.org/download/pgadmin-4-windows/ - para poder gerenciar as informações do PostgreSQL usando uma interface gráfica.

Abaixo vemos a tela de abertura do pgAdmin, após o login no PostgreSql:

Criando um novo projeto ASP .NET Core no VS for Mac

Abra o Visual Studio for Mac e clique no botão New Project:

A seguir selecione .NET Core -> App e a seguir o template ASP .NET Core -> ASP .NET Core Web App :

Informe o nome aspnet_mac selecione um local para criar o projeto a seu gosto e clique no botão Create :

Será criado o projeto contendo a estrutura exibida na figura abaixo:

Observe os arquivos do projeto:  Startup.cs, appsettings.json, as pastas Views, Controllers e as dependências Nuget.

Incluindo uma referência ao provedor PostgreSQL no projeto via Nuget

Vamos agora incluir uma referência ao Npgsql.EntityFrameworkCore.PostgreSQL em nosso projeto. Para isso clique com o botão direito sobre Nuget e a seguir clique em Add Packages:

A seguir selecione o pacote e clique em Add Package:

Para poder usar o recurso Migrations precisamos incluir também uma referência às ferramenta Microsoft.EntityFrameworkCore.Tools.Design. 

O Visual Studio for Mac 2017 atualmente (abril de 2017) não suporta a adição de uma referência a Microsoft.EntityFrameworkCore.Tools.DotNet e retorna o seguinte erro:

Package 'Microsoft.EntityFrameworkCore.Tools.DotNet 1.0.1' has a package type 'DotnetCliTool' that is not supported by project 'MacMvc'.

Para poder incluir a referência teremos que editar o arquivo de projeto aspnet_mac.csproj usando o VS Code e incluir a referência 'na mão' conforme mostrado a seguir:

Incluimos as seguintes linhas de código no arquivo aspnet_mac.csproj:

<ItemGroup>
    <DotNetClitoolReference Include=" Microsoft.EntityFrameworkCore.Tools.Design." Version="1.0.1" />
</ItemGroup>

A seguir confirme a restauração das dependências ou digite o comando :  dotnet restore  no console estando no diretório do projeto.

Precisamos deste recursos pois vamos usar o Migrations code-first para poder criar o banco de dados e as tabelas no PostgreSQL.

Ao final nosso projeto deverá exibir as seguintes referências Nuget:

Criando o nosso modelo de entidades

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

A nossa aplicação será bem simples e vai gerenciar informações de Autores e Artigos , portanto vamos definir as entidades :  Autor e Artigo.

A seguir vamos criar as classes que representam as nossas entidades.

Criando as entidades Autor e Artigo

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.

Clique com o botão direito do mouse sobre o projeto e a seguir clique em Add-> New Folder;



Informe o nome Models para criar esta pasta no projeto.

As classes são criadas na pasta Models clicando com o botão direito sobre a pasta, selecionando Add -> New File;

A seguir selecione o item General e a seguir Empty Class e informe o nome Autor:

Inclua o código abaixo nesta classe:

using System;
using System.Collections.Generic;
namespace aspnet_mac.Models
{
    public class Autor
    {
        public int Id { get; set; }
        public string Nome { get; set; }
        public string Sobrenome { get; set; }
        public List<Artigo> Artigos {get; set; } = new List<Artigo>();
    }
}

Repita o procedimento e crie a classe Artigo com o código abaixo:

using System;
namespace aspnet_mac.Models
{
    public class Artigo
    {
        public int Id { get; set; }
        public string Titulo { get; set; }
        public string Url { get; set; }
        public string Body { get; set; }

        public int AutorId { get; set; }
        public Autor Autor {get; set; } 
    }
}

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 diversas tarefas.

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. Neste projeto, a nossa classe de contexto será chamada AutorContext.

Para simplificar, usando os mesmos procedimentos anteriores, eu vou criar essa classe na pasta Models. Então crie o arquivo AutorContext.cs na pasta Models e a seguir inclua o código abaixo:

using Microsoft.EntityFrameworkCore;
namespace aspnet_mac.Models
{
    public class AutorContext : DbContext
    {
        public AutorContext (DbContextOptions<AutorContext> options) : base(options)
        {
        }
        public DbSet<Artigo> Artigos { get; set; }
        public DbSet<Autor> Autores { get; set; }
    }
}

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

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 ArtigoContext como um serviço, abra o arquivo Startup.cs e adicione as linhas realçadas ao método ConfigureServices:

using Microsoft.EntityFrameworkCore;
using aspnet_mac.Models;
...
....

// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { var connectionString = Configuration["dbContextSettings:ConnectionString"]; services.AddDbContext<ArtigoContext>(options => options.UseNpgsql(connectionString) );
            // 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 abrir o arquivo appsettings.json e adicionar a string de conexão conforme mostrado a seguir:

{
  "Logging": {
    "IncludeScopes": false,
    "LogLevel": {
      "Default": "Warning"
    }
  },
  "DbContextSettings": {
    "ConnectionString": "User ID=postgresql;Password=??????;Host=localhost;Port=5432;Database=DemoArtigos;Pooling=true;"
  }
}
 

A string de conexão especifica um banco de dados identificado pelo nome DemoArtigos, usuário postgres na porta 5432.

Gerando o banco de dados e as tabelas usando Migrations via EF Core Tools

Agora, temos a nossa instância do PostgreSQL iniciada e os nossos modelos criados, assim  podemos usar as ferramentas do EF Core para expandir nossas migrações e atualizar nosso banco de dados!.

Para isso vamos usar a ferramenta dotnet CLI e com ela executar nossas migrações diretamente na linha de comando.

Abra uma janela de comando e posicione-se na pasta do projeto (a pasta onde esta o arquivo aspnet_mac.csproj).

A seguir digite o comando abaixo:

$ dotnet ef migrations add MigracaoInicial


Compilation succeeded.  
    0 Warning(s)
    0 Error(s)
Time elapsed 00:00:01.5865396

Done. To undo this action, use 'dotnet ef migrations remove'  

Este comando constrói o projeto e, em seguida, gera os arquivos de migração. Como esta é a primeira migração, também criará a pasta Migrations no seu projeto e adicionará as novas migrações para ela.

Você pode abrir a pasta e verificar os arquivos gerados.

Para aplicar a migração gerada para o banco de dados usamos o seguinte comando:

$ dotnet ef database update 
Compilation succeeded.  
    0 Warning(s)
    0 Error(s)
Time elapsed 00:00:01.9422901
Done.  

Ao término desses comandos veremos no projeto a pasta Migrations criada contendo os arquivos de migração conforme figura abaixo:

Se você abrir o PgAdmin 4 neste momento vai visualizar o banco de dados DemoArtigos e as tabelas Autores e Artigos criados no PostgreSQL conforme mostra a figura a seguir:

Pronto ! Temos nossas entidades e agora as tabelas geradas no PostGreSQL prontos para serem usadas.

Vamos aproveitar e incluir um registro em cada tabela para podermos exibir alguma informação no teste.

Vamos usar o pgAdmin 4 definindo instruções SQL - INSERT INTO - conforme mostra as figuras:

1- Incluir um registro na tabela Autores

 

2- Incluir um registro na tabela Artigos

Neste código verificamos se existem dados na tabela Livros e a seguir incluimos informação de dois livros usando o método SaveChanges.

Criando um novo Controller

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.

Clique com o botão direito sobre a pasta Controllers e a seguir clique em Add New File;

A seguir selecione ASP .NET Core e o item MVC Controller Class e informe o nome AutoresController:

A partir daqui você decide se deseja criar as views do MVC ou criar uma Web API pois na ASP .NET Core o controlador tanto MVC como Web API herdam de Controller.

Vamos criar primeiro uma Web API definindo métodos que mapeiam para requisições GET e POST. Com isso em mente inclua o código abaixo no controlador AutoresController:

Neste código note que o controlador toma o nosso contexto, AutorContext, como um parâmetro de construtor que é injetado pelo contâiner de DI da ASP .NET Core.

Criamos os seguintes mapeamentos:

  • GET - api/autores - retorna todos os autores existentes;
  • GET - api/autores/{id} - retorna um autor pelo seu id;
  • POST - api/autores - inclui um autor;

Apenas para fazer um teste execute a aplicação a no navegador informe a url :  localhost:xxxx/api/autores

O resultado írá exibir os autores existentes conforme mostra a figura baixo:

Vemos que a nossa Web API esta respondendo corretamente.

Na próxima parte do artigo vamos ajustar o controlador HomeController e definir um método para retornar uma view e assim exibir os autores cadastrados.

E, como Moisés levantou a serpente no deserto, assim importa que o Filho do homem seja levantado;
Para que todo aquele que nele crê não pereça, mas tenha a vida eterna.

João 3:14,15

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