Alura > Cursos de DevOps > Cursos de Builds > Conteúdos de Builds > Primeiras aulas do curso Build de uma aplicação .NET: construindo seus projetos com MSBuild

Build de uma aplicação .NET: construindo seus projetos com MSBuild

O arquivo CSPROJ - Introdução

Para quem não me conhece, eu me chamo Daniel Portugal, um prazer estar aqui com vocês, para quem me conhece, sabe que aqui na Alura eu sou instrutor de cursos voltados para plataforma .NET e para linguagem CSharp. Nesse curso, eu quero apresentar mais um tópico para vocês estudarem, presta atenção nesse vídeo que eu vou explicar os objetivos de aprendizagem e você decide se você quer continuar assistindo o curso inteiro ou não.

Dá uma olhada na beleza desse Visual Studio, olha como ele é bonito e olha bem porque vai ser a última vez que vocês vão ver o Visual Studio aberto neste curso, me acompanha que eu vou explicar por quê.

Esse é um programa que é o Console Application, normal, tem apenas um entry point aqui, um método Main estático, que escreve no terminal o Hello World normal, como eu executo esse programa? Eu vou no botãozinho do Visual Studio e ele executa e apresenta para mim a mensagem, vou fechar.

Agora a pergunta que eu faço para vocês é: Vocês sabem o aconteceu por baixo dos panos para poder executar esse programa? Meu objetivo é justamente apresentar, iluminar um pouco esse processo entre o clique nesse botão e a execução do programa.

Uma coisa que é feita assim pelo Visual Studio, claro que esse é um projeto muito pequeno, projetos maiores vão demorar um pouquinho mais, mas ainda assim é um processo bastante rápido de acontecer, eu vou fazer com que esse processo aumente bastante, porque eu quero iluminar o que está acontecendo entre esse clique desse botão e a execução do programa.

Para isso, vamos precisar prescindir do Visual Studio, eu tirando o Visual Studio da jogada, vamos tentar entender quais são os passos que acontecem entre esse clique desse botão e a execução do programa, parece que é uma coisa só, o clique já faz com uma coisa só, mas na verdade, alguns processos estão acontecendo aqui no meio do caminho.

Só para vocês terem uma ideia, existe um outro arquivo fonte que está envolvido nesse processo, que entra em ação no momento desse clique e esse cara fica escondidinho no Visual Studio, mas quando você clica com o botão direito no projeto e em editar arquivo do projeto, vocês vão conhecer esse arquivo.

O primeiro o objetivo desse curso é apresentar esse arquivo, o formato desse arquivo, que eu já vou fazer um spoiler, é um formato do MSBuild, que é a ferramenta de compilação de build da plataforma .NET, o primeiro objetivo é entender esse formato para que consigamos ter uma nova leitura para outros arquivos que aparecerem nos seus projetos .NET.

Esse é o primeiro objetivo, entender o formato do MSBuild, saber que esse é o primeiro cara que entra em ação quando eu clico com esse botão do play do Visual Studio.

O segundo objetivo do curso é mostrar para vocês que esse arquivo csproj é um script de compilação, esse script de compilação é pequenininho assim, mesmo para projetos grandes, esse script de compilação ainda assim é bastante curtinho, isso só é possível com a ajuda de um pacote que a Microsoft disponibiliza para desenvolvedores, que é chamado de Kit de Desenvolvimento de Software, ou SDK, vocês estão vendo que no próprio csproj nós temos referência a um SDK da Microsoft, no caso o Microsoft.Net.Sdk.

O terceiro objetivo, eu quero mostrar para vocês aqui no Visual Studio, quando eu clico nesse botão aqui é executado o nosso programa, vou fechar, só que repara que antes desse botãozinho eu tenho duas listas com opções que eu posso escolher.

O que é esse negócio de Gerenciador de configurações? Na verdade nós temos aqui no Visual Studio, duas configurações para o processo de compilação, uma configuração chamada Debug e uma configuração chamada Release e o terceiro objetivo é justamente mostrar para vocês do que se trata esses dois caras, vocês vão ver que você pode compilar o seu projeto com dois grandes objetivos em mente, um para você fazer o seu diagnóstico, da sua lógica, da sua regra de negócio e outro para você entregar o seu software.

O quarto objetivo é conhecer uma ferramenta que abstrai todo esse processo para nós, essa ferramenta já é utilizada para execução desse projeto chamado dotnet, vocês vão ver que ela também pode ser utilizada para outros propósitos, nosso quarto objetivo é conhecer o dotnet CLI, de Command Line interface.

E o quinto e último objetivo é aplicarmos todos esses conceitos aprendidos para simular o clique do botão no Visual Studio, a tecla de atalho F5 desde a compilação até a execução de um programa, simularmos esse processo todo numa imagem docker, então vamos criar uma imagem docker com todos os componentes de arquitetura necessários para você compilar um programa .NET e depois executar esse programa.

Será que vamos conseguir? Minha amiga e meu amigo, se você ficou interessado em conhecer mais sobre MSBuild, csproj, SDK, .NET CLI, vem comigo para mais um curso da Alura.

O arquivo CSPROJ - Sem Visual Studio

O objetivo desse vídeo é de estudar um pouco processo de compilação de um projeto CSharp, como isso funciona dentro da plataforma .NET, então se você já descompactou aquele projetinho que eu coloquei na atividade anterior agora você vai abrir isso, só que você vai abrir em um editor de texto e não vai abrir no Visual Studio, pode ser o Bloco de Notas, pode ser o Visual Studio Code, eu vou abrir nessa máquina, no Notepad++.

Está aqui o Notepad++ com aqueles quatro arquivos que estão dentro do Zip e eu vou trabalhar especificamente nesse primeiro momento com essa classe Program, ela representa um programa porque nós temos um método estático chamado Main que não retorna nada e isso é considerado como um entry point, um ponto de entrada para o programa, esse programa não faz nada além de escrever no terminal, Alô, mundo.

Então agora quero saber o seguinte: como eu faço para executar esse programa dentro do .NET, dentro do Runtime .NET, primeiro eu preciso compilar esse arquivo e depois executar esse cara no Runtime, sem Visual Studio, então para isso, vamos usar uma ferramenta que é instalada junto com o Visual Studio, chamada Prompt de Comando do Desenvolvedor.

Eu vou no iniciar do Windows e vou escrever “dev”, ou pode ser desenv se estiver em português instalado na sua máquina e vou abrir esse arquivo, essa ferramenta chamada Developer PowerShell para o Visual Studio 2019, é um terminal, só que com algumas variáveis de ambiente configurados a mais.

A primeira coisa que eu quero fazer é ir para o diretório onde eu extrai esses arquivos, estão aqui nossos quatro arquivos CSharp, só que eu quero olhar primeiro para o Program.cs, o que eu vou fazer? Eu quero executar esse cara, eu quero mostrar no terminal Alô, mundo, esse é o meu objetivo inicial.

Para fazer isso, primeiro eu preciso sair de CSharp e compilar isso em uma linguagem intermediária, no caso do .NET é a IL, Intermediate Language, no Java chamamos de Bytecode, mas no caso do CSharp, no .NET, é IL, para isso eu preciso usar uma ferramenta que vai tirar desse arquivo fonte, cs para esse arquivo intermediário, essa ferramenta no CSharp é csc, o CSharp Compiler e eu preciso, para fazer essa ferramenta funcionar, dizer qual é o arquivo que eu quero compilar, “Program.cs”.

Ele vai rodar o compilador e vocês vão ver que agora, se eu der um “dir” aqui, eu tenho mais um arquivo gerado, um arquivo chamado Program.exe, deixa eu destacar para vocês esse arquivo, que foi o arquivo que foi gerado a partir do meu processo de compilação, vocês vão ver depois que o Visual Studio vai fazer isso de uma maneira muito mais elaborada, é claro, mas vai fazer isso também.

Então agora eu já consigo executar esse cara, no caso do PowerShell, “.\Program.exe” para executar esse cara e ele falar, deixa eu dar um “clear” aqui e colocar tudo lá para cima, está lá o nosso Alô, mundo do MSBuild, funcionou tudo bem, só que se você reparar direito eu estou com um diretório onde eu estou confundindo as coisas um pouco, porque eu estou com o código-fonte aqui e o executável aqui também, precisamos melhorar um pouco isso.

Uma maneira que eu posso fazer isso é usar um parâmetro chamado “-out” no meu csc onde eu vou dizer: “Eu quero que esse Program.exe seja gerado em um diretório chamado Bin” e eu tenho também que dizer, claro, qual é o arquivo que eu quero compilar, estou dizendo, deixa eu fazer uma revisão com vocês rápido.

Estou novamente apontando para qual é o arquivo CSharp que eu quero compilar e também estou dizendo agora que eu quero colocar esse Program.exe no arquivo bin, vamos executar esse cara e aconteceu um erro, não é possível abrir bin\Program.exe para escrever, não foi possível localizar uma parte do caminho, é claro.

“clear”, “dir”, não tem essa pasta, essa pasta bin ainda não existe, eu tenho que chegar aqui e fazer um “mkdin bin”, fazer um “clear”, um “dir”, agora a minha pasta está lá e se eu executar novamente aquele cara, funciona, deixa eu dar um “clear” e eu tentar agora executar, “.\bin\Program.exe”, funcionou porque agora o meu Program.exe está dentro da pasta bin, o Notepad++ está inclusive já mostrando isso tudo para mim, de uma forma visual, como eu estou fazendo aqui.

Para fazer isso, eu precisei então criar a pasta e passar aquele comando csc para executar isso e inclusive colocando qual é a pasta onde vai ser gerado o arquivo intermediário, isso fica na cabeça, tivemos que fazer dois passos para poder gerar essa compilação, para deixar um pouco mais organizado o nosso código, inclusive eu vou até remover o arquivo Program.exe que está naquele diretório.

Agora eu tenho o diretório principal com o código fonte e um diretório intermediário, auxiliar, para colocar o arquivo executável, separamos um pouco agora as responsabilidades nos nossos diretórios.

Vamos passar agora para um outro passo que é o seguinte, vou fechar esse arquivo Program.exe e vou para esse arquivo ListaTarefas.cs que também é um programa, também tem um ponto de entrada, só que é um programa um pouquinho mais elaborado, ele usa duas classes a mais, uma classe que representa uma tarefa, que está aqui, e uma classe que representa uma categoria de uma tarefa, que está aqui.

Eu crio alguma lista de tarefa com várias categorias, lazer, estudo, finanças, depois eu gero um relatório, agrupando por categoria e ordenando pelos dias que essas tarefas vão ter que ser concluídas, no terminal, eu quero mostrar por categoria as tarefas que vão vou ter que ser concluídas primeiro, então eu preciso compilar esse cara, vamos usar os nossos conceitos, que já aprendemos aqui para compilar esse cara.

Vou fazer um “clear” novamente, “csc -out”, não se esqueçam de fazer isso, “bin” e aqui eu vou colocar “Tarefas” - o nome pode ser diferente - e eu quero o arquivo “ListaTarefas.cs”, nosso programa, tudo que já aprendemos, apertar Enter aqui e o nosso computador vai reclamar, está dando um erro aqui, nome de tipo ou namespace “Modelos” não existe no namespace “Alura.MsBuild, Você está sem uma referência de assembly? Não, não estou sem referência de Assembly nenhuma porque está tudo dentro desse mesmo diretório.

É porque na verdade esses caras estão namespace diferentes, Alura.MsBuild.Modelos, só que eu estou dando o using, using Alura.MsBuild.Modelos”, qual o problema afinal? O problema é que eu tenho que compilar também esses arquivos, Tarefas e Categoria, como eu faço para juntar agora esses arquivos nessa tarefa de csc? Eu coloco eles lado a lado, “Tarefa.cs Categoria.cs”, então coloquei mais esses dois arquivos aqui.

Aperta Enter, tudo volta a funcionar, dá um “clear” e agora eu vou tentar executar - tem que colocar um ponto - o “Tarefas.exe” e funcionou, agora está exibindo no meu terminal o relatório de tarefas com as tarefas ordenadas pelas que tem que ser concluídas mais cedo primeiro, então funcionou.

Mas reparem o seguinte, nessa rápida exposição, reparem que eu tenho algumas coisas que são muito repetitivas e problemáticas, primeiro, a geração desse diretório auxiliar para guardar o executável, eu tive que criar este diretório, se eu esquecer de fazer isso numa máquina zerada, vai dar erro de compilação, no csc.

Um outro problema que nós vimos aqui também é que a medida que o meu projeto vai aumentando, as classes vão aumentando, os arquivos com essas classes também, então eu vou ter que colocar no meu csc aquele monte de arquivos cs, vai ter uma hora que isso vai ficar inviável, vou começar a errar a digitação, errar de esquecer de colocar, eu percebo e você também está percebendo que esse processo não está sendo produtivo, vamos agora começar a pensar em uma maneira de melhorar esse processo de compilação.

O arquivo CSPROJ - Script

Nesse vídeo, estamos buscando um pouco mais produtividade na hora de fazer o nosso processo de compilação dos nossos projetos, ao invés de ficarmos executando comandos de forma isolada no nosso terminal, vamos buscar uma coisa que agrupe todo esse processo de compilação em um arquivo só.

A primeira coisa que vamos tentar fazer é um script para executar esse processo, que por enquanto é muito simples, verificar se precisamos criar uma pasta chamada bin e chamar de fato a lista de arquivos para ser compilada, gerando esse arquivo intermediário nessa pasta que foi gerada.

Podemos fazer um Script para isso, eu vou colocar um “mkdir bin” e depois eu vou colocar um “csc -out:bin\Tarefas.exe” e aqui todos os arquivos necessários para a compilação, “ListaTarefas.cs Tarefa.cs Categoria.cs”, será que é só isso? Eu vou salvar esse cara em um arquivo, vou chamar ele de “compile.bat”, salvei, agora eu posso tentar chamar esse cara, dá um “clear” aqui e vou, “.\compile.bat” e ele executou o que queríamos, a única coisa é que já existe uma pasta, não precisou fazer e chamou aquele cara que tínhamos antes.

Esse é o processo ideal, termos um arquivo que represente o nosso processo de compilação, porque vamos inclusive entregar esse arquivo para uma máquina executar, para ser automatizado, na verdade esse é o grande objetivo desse curso, descobrirmos como podemos automatizar o processo de compilação do nosso projeto colocando isso em um servidor de integração contínua, enfim.

Porque no Visual Studio é você que aperta o botão, não queremos mais fazer isso, queremos automatizar esse processo, inclusive através de algum tipo de evento, algum código foi publicado, comentado em algum ramo do seu repositório, algum evento que acontece relativo ao seu projeto, você gera uma nova versão, compila uma nova versão do seu projeto e possivelmente até pública em algum servidor, tudo isso é possível de ser automatizado.

Estamos começando bem pequenininho esse processo e estamos entendendo que a ideia é gerar esse script, organizar todo o processo de compilação e o script.

O problema de ser um script como esse aqui, é que ainda estamos muito manual, precisamos escrever esses caras, se aparecer um novo arquivo, vamos ter que modificar esse script, essa criação de diretório também está muito específica para esse sistema operacional, se eu tiver que gerar esse processo de compilação em uma máquina Linux, por exemplo, vai ser diferente.

Agora eu tenho que conhecer tanto os comandos PowerShell, os comandos do Unix e tudo mais, eu preciso abstrair um pouco esse processo e como vamos fazer isso? Vamos descobrir que existe um formato de arquivo que vai nos ajudar a extrair e uniformizar esse processo de compilação, que vamos ver no próximo vídeo.

Sobre o curso Build de uma aplicação .NET: construindo seus projetos com MSBuild

O curso Build de uma aplicação .NET: construindo seus projetos com MSBuild possui 206 minutos de vídeos, em um total de 62 atividades. Gostou? Conheça nossos outros cursos de Builds em DevOps, ou leia nossos artigos de DevOps.

Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:

Aprenda Builds acessando integralmente esse e outros cursos, comece hoje!

Plus

  • Acesso a TODOS os cursos da plataforma

    Mais de 1200 cursos completamente atualizados, com novos lançamentos todas as semanas, em Programação, Front-end, UX & Design, Data Science, Mobile, DevOps e Inovação & Gestão.

  • Alura Challenges

    Desafios temáticos para você turbinar seu portfólio. Você aprende na prática, com exercícios e projetos que simulam o dia a dia profissional.

  • Alura Cases

    Webséries exclusivas com discussões avançadas sobre arquitetura de sistemas com profissionais de grandes corporações e startups.

  • Certificado

    Emitimos certificados para atestar que você finalizou nossos cursos e formações.

  • Alura Língua (incluindo curso Inglês para Devs)

    Estude a língua inglesa com um curso 100% focado em tecnologia e expanda seus horizontes profissionais.

12X
R$85
à vista R$1.020
Matricule-se

Pro

  • Acesso a TODOS os cursos da plataforma

    Mais de 1200 cursos completamente atualizados, com novos lançamentos todas as semanas, em Programação, Front-end, UX & Design, Data Science, Mobile, DevOps e Inovação & Gestão.

  • Alura Challenges

    Desafios temáticos para você turbinar seu portfólio. Você aprende na prática, com exercícios e projetos que simulam o dia a dia profissional.

  • Alura Cases

    Webséries exclusivas com discussões avançadas sobre arquitetura de sistemas com profissionais de grandes corporações e startups.

  • Certificado

    Emitimos certificados para atestar que você finalizou nossos cursos e formações.

  • Alura Língua (incluindo curso Inglês para Devs)

    Estude a língua inglesa com um curso 100% focado em tecnologia e expanda seus horizontes profissionais.

12X
R$120
à vista R$1.440
Matricule-se
Conheça os Planos para Empresas

Acesso completo
durante 1 ano

Estude 24h/dia
onde e quando quiser

Novos cursos
todas as semanas