C#: PostgreSQL e .NET Core 2.1

Certas vezes é inviável contar com um banco de dados pago quando o projeto está iniciando. Mas nem por isso não será preciso que seja um repositório de dados profissional. Portanto, neste artigo ensino como usar o banco de dados relacional PostgresSQL com o .NET Core 2.1, ainda usando Entity Framework Core e Migrations.

Antes de começar você vai precisar:

  1. Ter o PostgreSQL instalado, com a senha do localhost como 123456,
  2. Ter o Visual Studio Code intalado,
  3. Ter o .NET Core 2.1 SDK instalado.

Criando o projeto

Crie uma pasta vazia chamada PostgreSqlNetCore e dentro dela crie uma outra chamada src. E na pasta raíz, crie o arquivo da solução, usando o comando:

Abra a a pasta src e crie dentro dela a pasta PostgreSqlNetCore.Domain, e neste diretório execute o comando abaixo para criar o projeto do domínio:

Crie uma pasta chamada Entities, e adicione duas classes, uma de pessoa e outra de categoria.

Agora vamos criar o projeto que conterá nossa camada de acesso a dados, migrations e CRUD. Abra a a pasta src e crie dentro dela a pasta PostgreSqlNetCore.Infra.Data, e neste diretório execute o comando abaixo para criar o projeto de domínio:

Instale os pacotes conforme a seguir:

Npgsql.EntityFrameworkCore.PostgreSQL

Microsoft.Extensions.Configuration.FileExtensions

Microsoft.Extensions.Configuration.Json

Adicione a referência ao projeto de domínio, com o comando:

Crie uma pasta chamada Context, e adicione uma classe chamada PostgreSqlContext.

Abra a a pasta src e crie dentro dela a pasta PostgreSqlNetCore.Prompt, e neste diretório execute o comando abaixo para criar o projeto de domínio:

Instale o pacote Microsoft.EntityFrameworkCore.Design.

Adicione referência ao projeto de Dados.

Na raiz do projeto, adicione um arquivo chamado appsettings.json, e altere conforme a seguir:

Adicione ainda na raiz do projeto a classe DesignTimeDbContextFactory.

Agora é preciso associar todos os projetos na solução, e para isso, abra a pasta raiz no terminal, e execute os comando a seguir:

Agora é só executar o comando para criar a migração.

E então atualizar o banco de dados.

E enfim podemos ver o banco de dados com as nossas tabelas criadas e o versionamento das migrations.

Acesse o repositório no githus deste projeto no link a seguir:

https://github.com/tiagopariz/PostgreSqlNetCore

Obrigado, e até a próxima.

C# e Mvc: mapa do Google com marcadores

Você já precisou colocar um mapa em seu site ou aplicativo? E este mapa precisaria mostrar vários locais, como unidades comerciais de um empresa com filiais? Neste artigo eu mostro como exibir um mapa usando a API Google e adicionar os devidos marcadores em um site feito em C# e MVC.

Mas primeiro, você vai precisar de uma chave do Google API Maps, que pode ser adquirida no endereço:

Chave na mãe, vamos criar uma pasta chamada CSharpMvcGoogleMapWithMarkers e dentro dela incluir outra chamada src e então abrir no Visual Studio Code.

Se você ainda não usou o VS Code e/ou ainda usa apenas o Visual Studio convencional, eu fiz um artigo para quebrar  o gelo com este editor opensource da Microsoft.

Dentro da pasta src, crie outra pasta chamada CSharpMvcGoogleMapWithMarkers.Mvc, volte na pasta raiz e abra esta pasta no terminal e vá digitando os comandos a seguir:

Crie uma solução, para que seja possível abrir no Visual Studio convencional:

Abra a pasta do projeto MVC:

Crie um projeto C# do tipo MVC:

Volte a pasta raiz:

Adicione o projeto MVC na solução:

Execute o site e veja no navegador:

A saída do terminal será esta, onde o VS Code vai informar a URL local para testar, normalmente https://localhost:5001 ou http://localhost:5000.

Copie e cole no navegador o endereço e confira a página:

Crie um novo controller, chamado StoreController, que será uma tela com um mapa e ponto onde há lojas de uma empresa. Para isso, clique o botão direito sobre a pasta Controllers, clique em New file e defina o nome como StoreController.cs.

Clique o botão direito sobre a pasta Models, clique em New file e defina o nome como StoreViewModel.cs.

Para facilitar, adicione um novo item de menu chamado Know our stores que abre a action Index do controller Store, para isto edite o arquivo Views/Share/_Layout.cshtml.

 

Clique o botão direito sobre a pasta Views, clique em New folder e digite Store, em seguida clique o botão direito sobre Store e em New file e defina o nome como Index.cshtml.

Explicando o código Javascript do mapa

Declaramos uma variável chamada map e criamos uma função initMap (), serão informadas as coordenadas inciais e logo após definido os marcadores.

Agora vamos definir a posição e o zoom do mapa, instanciando um novo objeto google.maps.Map, que recebe os parâmetros  que informa qual a div que será renderizado o mapa, as coordenadas e o zoom.

Se você quiser entender melhor como funciona o Zoom e demais opções, clique no link abaixo para a documentação do google:

https://developers.google.com/maps/documentation/javascript/tutorial

Agora, com o mapa pronto, é adicionar os marcadores, para isso é só instanciar um objeto do tipo google.maps.Marker e usar a função setMap().

Segue a documentação do Google sobre marcadores:

https://developers.google.com/maps/documentation/javascript/markers

Ao carregar o mapa, todas as lojas serão exibidas como marcadores no mapa.

Pronto, agora temos uma mapa com marcadores de locais.

Este projeto pode ser conferido no meu repositório do GitHub:

  • https://github.com/tiagopariz/CSharpMvcGoogleMapWithMarkers

OpenCover: analisando e automatizando a cobertura de código

Cobertura de código é essencial para sabermos o quanto estamos investindo na qualidade do nosso projeto. Para isso, até temos recursos nativos na IDE do Visual Studio, mas apenas na edição Enterprise. Mas nem tudo está perdido para quem não tem acesso à edições “premium” do VS! Podemos substituir tranquilamente pelo OpenCover, que atende a este necessidade com grande eficiência e elegância. E isso veremos no projeto de exemplo que iremos montar com o Visual Studio 2017 e o NUnit.

Observação: o OpenCover atende outras plataformas de testes, inclusive a nativa da Microsoft, irei o Usar o NUnit apenas por escolha própria, fique a vontade para integrar com a ferramente que convir.

Crie a solução dos projetos

Crie uma solução vazia chamada CodeCoverage, e inclua três Solution Folders chamadas Domain, Presentation e Tests. na pasta Tests, inclua mais duas subpastas chamadas Domain e Presentation, que serão os testes específicos de cada camada.

Projeto de domínio

Crie um projeto do tipo Class Library chamado CodeCoverage.Domain dentro da pasta Domain, e dentro do projeto inclua outra pasta chamada Entities. Nesta pasta inclua três classes chamadas State, City e Person, pois estas classes que serão analisadas pelo OpenCover, afim de gerar um relatório com o percentual de cobertura por testes unitários. A seguir o código de cada uma delas:

Classe de estados

Classe de cidades

Classe de pessoas

Projeto de Console

O projeto de console, será a nossa camada de apresentação, onde vamos trabalhar com DTOs, que são representações dos dados das nossas classes de domínio. Para isso, na pasta Presentation da solução, adicione um projeto do tipo Console Application chamado CodeCoverage.Prompt, e dentro do projeto inclua um pasta chamada Dto. Onde residirão as 3 classes de dados que serão a StateDto, CityDto e a PersonDto, como segue:

DTO de estado

DTO de cidades

DTO de pessoa

Edite a classe Program.cs e crie o método  que faz os mapeamento entre o Domínio e DTO e o código que exibe os dados em tela.

Observação: não é intenção deste artigo explicar como funciona processos de mapeamentos entre entidades de domínio, DTOs e ViewModels. Mas fica a dica para você procurar na internet qual o funcionamento de um AutoMapper, por exemplo.

Testes

Expanda a pasta de solução Tests e dentro da pasta Domain adicione um projeto do tipo Unit Test Project chamado CodeCoverage.Domain.Tests.

Neste projeto, inclua uma pasta chamada Entities, e dentro dela vamos incluir duas classes de testes, mas antes é preciso instalar o pacote NUnit, para isso abra o Package Manager Console selecione o projeto de testes do domínio e digite:

Adicione uma referência para o projeto de domínio, para que os testes possam acessar as entidades. Então adicione as classes de testes na pasta Entities.

Testes da classe de estado

Testes da classe de pessoa

Adicione um outro projeto do tipo Unit Test Project chamado CodeCoverage.Prompt.Tests e adicione uma referência do projeto CodeCoverage.Prompt e instale o pacote do NUnit também.

Crie uma pasta chamada Dto, e dentro dela inclua uma classe de testes chamada PersonDtoTests para pessoas.

Usando o Cake

Abra o Powershell, e se posicione na pasta da solução, e logo após digite o comando para instalar o pacote que compila e executa o script do Cake:

Ainda na pasta raiz da solução, crie um novo arquivo chamado build.cake e crie também a pasta docs/testsResults/Reports, que será onde ficará os resultados dos testes.

Dica: você pode adicionar o arquivo build.cake à solução, para que ele faça parte do projeto, mas é muito mais produtivo usar o Visual Studio Code e a extensão do Cake, conforme expliquei neste artigo.

Volte ao Powershell e digite o comando .\build.ps1 para executar o script do Cake.

Após a execução do script, o Report Generator irá compilar os arquivos xml do OpenCover e gerar uma visualização mais amigável e detalhada e ainda abrir um sumário no seu navegador padrão, incluind um histório de cobertura.

.gitignore

Se você está usando o arquivo .gitignore padrão do Visual Studio – aquele que é fornecido, por exemplo, pelo GitHub ou Visual Studio Online – será preciso alterar para que ele ignore os arquivos compilados do Cake e não suba para o repositório do GitHub. Para isso encontre o trecho a seguir:

E descomente as duas últimas linhas.

Pronto, agora podemos acompanhar a evolução dos testes de nosso aplicativo de forma elegante e segura.

Até a próxima e se quiser, acesse o projeto completo em meu GitHub:

https://github.com/tiagopariz/CodeCoverage

Cake: automatizando tarefas

O Cake é um automatizador de tarefas construído sobre o compilador do C# e de fácil configuração.

Instalando o Cake

Para usar o Cake, precisamos baixar os scripts de automação que vem todos em um arquivo chamado build.ps1 que roda no Powershell. Para isso, abra o Powershell, crie uma pasta chamada CakeAutomation.

Com a pasta criado, execute o comando para baixar o pacote com as configurações.

Pronto, o ambiente está configurado, agora precisamos de um projeto para automatizar.

Crie uma aplicação de exemplo

Eu tenho um post que ensina como criar uma aplicação console com o Visual Studio Code, vamos usar este exemplo para automatizar uma build:

Visual Studio Code: como criar uma aplicação console em C#

Crie o script de build da aplicação com o Cake

Na raiz do projeto, inclua uma arquivo chamado build.cake, que será onde residirá todo o código de automação. Edite o arquivo conforme segue:

Agora o script está pronto para ser rodado, para isso, é preciso que você esteja na raiz do projeto, via powershell digite o comando a seguir:

Site oficial

https://cakebuild.net/

Extensão para VS Code:

https://marketplace.visualstudio.com/items?itemName=cake-build.cake-vscode

Repositório no GitHub:

https://github.com/tiagopariz/CakeAutomation

Visual Studio Code: como criar uma aplicação console em C#

O Visual Studio Code é o novo editor de código open-source da Microsoft, multiplataforma, que já funciona no Windows, Linux e Mac. Com foco no novo .NET Core, que também é um framework totalmente open-source. Porém, por mais simples que pareça, programar no VS Code é consideravelmente diferente do que programar no famigerado Visual Studio.

Requisitos

O projeto de console

Abra o Visual Studio Code, clique no menu View, e em seguida em Integrated Terminal (CTRL + ‘). No terminal, crie uma pasta usando o comando md chamada ConsoleApplicationVSCode (podem usar o explorer do Windows sem problemas).

No menu File, clique em Open folder, e selecione a pasta que acabamos de criar.

Na janela do terminal, posicione na pasta criada e digite o comando dotnet new console.

Abra o arquivo Program.cs.

Edite a classe Program.cs conforme o código a seguir:

Clique no menu Debug, e em seguida em Start Debugging (F5), e então teremos nossa aplicação console funcionando!

Este tutorial básico tem o objetivo de “quebrar o gelo” para começar a usar o VS Code, e também demonstrar que este editor é tão simples quando os seus antecessores, além do mais, em conjunto com as extensões corretas, pode virar uma poderosa ferramenta de trabalho!

Acesso o código fonte no meu GitHub:

https://github.com/tiagopariz/ConsoleApplicationVSCode