Visual Studio: instalando o Report Designer na versão 2017

Diferente das versões anteriores, o Report Designer não vem embarcado no Microsoft Visual Studio 2017, para usar é preciso instalar uma extensão.

Abra o Visual Studio, clique no menu Tools e em seguida em Extension and Updates.

Em Extension and Updates, clique em Online, em Search digite rdlc, em Microsoft Rdlc Report Designer for Visual Studio clique em Download e aguarde a transferência.

Depois de transferido você será avisado que a instalação será completa somente após fechar e abrir novamente, portanto clique em Close e reinicie o programa.

Ao abrir novamente, a instalação da extensão será iniciada.

Clique em Modify e aguarde o término da instalação.

Se o instalador avisar que tem processos em execução que o impede de continuar, salve seus dados e clique em End Tasks.

Após liberar os recursos, a instalação prosseguirá normalmente.

Ao concluir, clique em Close.

Pronto, agora é só abrir o VS e editar visualmente os relatórios baseados em RDLC.

Até a próxima.

 

VB.NET MVC: traduzindo do C# as aulas do Cleyton Ferrari

Cleyton Ferrari foi um dos primeiros profissionais de desenvolvimento C# brasileiros que fez um curso bem estruturado sobre MVC e Entity Framework, explicando nos detalhes como funcionava cada elemento, e melhor, tudo gratuito no Youtube.

Na época eu trabalhava com VB.NET, e por isso eu precisei traduzir o projeto didático dele para a linguagem que eu usava. Foi uma tarefa com dois ganhos, o primeiro que serviu para eu treinar meu C# que ainda era bem básico e segundo para entender a fundo o conceito do MVC e ORM com Entity Framework.

Não havia me preocupado em criar um post em 2013, e mal sabia usar o GitHub, mas guardei os fontes lá, e eles existem até hoje, por isso resolvi escrever para registrar isso aqui. Mas antes de entrar no meu repositório você quiser conferir os cursos dele, que apesar de ser feito para o ASP.NET MVC 3 ainda é bem válido:

E acesse aqui os projetos traduzido para VB.NET:

https://github.com/tiagopariz/CleytonFerrari

 

Visual Studio: o desafio de hoje é recolher e estrutura da solução sem usar o mouse

Um tarefa muito comum no dia a dia de um programador que usa o Microsoft Visual Studio é recolher todos as pastas da solução para facilitar a navegação pelos arquivos e projetos.

O simples fato de recolher uma estrutura como esta:

Para deixá-la assim:

Sempre foi é preciso largar um pouco o teclado e usar o mouse para clicar no botão Collapse All, pois não há um atalho nativo na IDE, mas seu problemas acabaram! pois é possível configurar um novo atalho, então vamos ao trabalho.

Clique no menu Tools, em seguida em Options.

Em Options, expanda Enviroment e clique em Keyboard, e use Show commands containing para encontrar o comando SolutionExplorer.CollapseAll.

Em Use new shortcut in, selecione Global e em Press shortcut keys pressione a tecla / (barra) e por fim clique em OK.

O atalho ainda tem um problema, pois ele só funciona quando o foco está na janela da solução, mas para contornar isso foi vai ter que decorar as combinação de teclas que trás esta janela para o primeiro plano. Então, tecle CTRL + ALT + L e logo após /, e pronto a solução está recolhida!

Até a próxima.

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

PostgreSQL: instalando no Windows

O PostgreSQL é um banco de dados relacional poderoso, e dentre os gratuitos open-source, um dos mais usados por pequenas e grandes empresas. Sem falar que é um projeto bastante maduro, sendo que vem sendo desenvolvido desde 1985.

Download

Para instalar o banco de dados, entre no site postgresql.org e clique em Download e em seguida em Windows.

Em Windows installers – Interactive installer by EnterpriseDB, clique em Download the installer e selecione o sistema operacional Windows x86-64 e finalmente em Download Now.

Instalação

Dê um duplo clique sobre o instalador que foi baixado, e aguarde o carregamento da tela inicial de instalação, e clique em Next.

Vá clicando em Next e mantenha as configurações padrão até chegar na tela password, onde digite e confirme a senha 123456, para fins de teste, e clique em Next.

Mantenha a porta 5432, e clique em Next.

Em Locale, selecione Portuguese, Brazil, e clique em Next.

Confira o sumário de instalação e clique em Next nesta e na próxima tela.

Aguarde o processo de instalação e clique em Finish.

O PostgreSQL está instalado e pronto para usar.

Até a próxima.

 

C#: Using e Dispose

Não vejo muitos softwares usando em seu código, pelo menos da maneira correta, o bloco using em conjunto método Dispose da interface IDisposable() da maneira correta. Mas vou mostrar em um exemplo bem simples como estes dois recursos podem ser poderosos para manter uma aplicação enxuta e performática.

Para começar, vamos criar uma solução chamada UsingAndDispose e incluir dois projetos, um projeto de domínio do tipo Class Library chamado UsingAndDispose.Domain e outro do tipo Console Application chamado UsingAndDispose.Prompt.

No projeto de domínio, vamos incluir uma classe chamada TxtFile, que recebe dois parâmetros via construtor, nome do arquivo e pasta, e com eles alimenta uma propriedade que retorna o caminho completo. Incluiremos também um método que efetuará o fechamento do arquivo após a leitura e limpará a memória, mas neste caso vamos apenas escrever um frase na tela do console.

Crie uma classe chamada TxtFile e defina uma herança da interface IDisposable, que exigirá a implementação do método Dispose, que chamará o método Close().

Obs.: Não vamos entrar na complexidade da lógica de leitura de um arquivo de texto de fato, mas apenas criar um classe que poderia implementá-la, o importante é entender o mecanismo do bloco using.

Então, no projeto de console, altere a classe Program.cs, incluindo um bloco using, conforme o código a seguir, e faça uma referência ao projeto de domínio para acessar a classe TxtFile.

Ao executar o código acima, percebemos que a mensagem do método Close é exibida em tela, mas o curioso que em nenhum momento o chamamos diretamente. Isso acontece porque a classe TxtFile implementa a interface IDisposable, e quando o using recebe objetos que são implementados a partir desta interface, automaticamente é chamado o método Dispose() ao fechar o bloco. E neste caso, o método Dispose() foi implementado com uma chamada ao método Close().

Acesse o projeto completo no meu GitHub:

https://github.com/tiagopariz/UsingAndDispose

 

 

Visual Studio: abrir a pasta atual do arquivo na solution

Muitas vezes trabalhamos com soluções complexas, com várias dezenas ou centenas de arquivos, e quando precisamos encontrar fisicamente o arquivo no disco ou no projeto, temos que olhar o tooltip da guia e abrir pasta a pasta.

Felizmente, tem uma opção, que não vem marcada por default no Visual Studio que facilita esta navegação. Ao ativar esta opção, a solution já abre a pasta e coloca o foco no arquivo assim que se inicia a trabalhar nele.

Para configurar esta opção, clique no menu Tools, e em seguida em Options, abra o nó Environment e clique em Documents. Deixe marcada a opção Open file using directory of currently active document e clique em OK.

Outro atalho bastante útil é CTRL + , (Control e vírgula), no qual é possível procurar arquivos por nome e referências.

Anote estas duas dicas, pois vão facilitar muito a navegação pela solução no seu dia a dia.

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

 

Git Bash: abrir a solução com o Visual Studio

Muitas vezes temos a nossa barra de tarefas lotada de atalhos, quanto que com alguns comando, sem sair da janela do Git Bash, podemos atualizar e abrir o projeto direto no Visual Studio.

Estes passos não exigem a criação de nenhum script específico, apenas comandos do próprio Git e Prompt do Windows. O roteiro a seguir tem no máximo 7 passos, que podem ser reduzidos com scripts, mas aqui você começa em uma branch desatualizada e termina dentro do Visual Studio, já pronto para trabalhar, sem nenhum clique a mais. Então vamos lá:

Criar uma nova branch a partir da master e abrir no Visual Studio

  1. Abra o Git Bash,
  2. Digite o comando que abre a pasta da solução,
  3. Atualize a master,
  4. Crie uma nova branch a partir da master,
  5. Digite cmd,
  6. Digite o nome da solução com a extensão e aguarde o Visual Studio carregar,
  7. Digite exit para sair do prompt do Windows e voltar ao Git Bash.

Segue um exemplo de comandos seguindo estes passos:

Atualizar uma branch existente e abrir no Visual Studio

  1. Abra o Git Bash,
  2. Digite o comando que abre a pasta da solução,
  3. Atualize a branch,
  4. Digite cmd que vai entra no modo prompt do Windows,
  5. Digite o nome da solução com a extensão e aguarde o Visual Studio carregar,
  6. Digite exit para sair do prompt do Windows e voltar ao Git Bash.

Dica

  • É possível configurar o atalho do Git Bash para abrir já na pasta dos projetos mais usados.