Primeiros passos com C# e o Mono #01
Tags: linux, mono, nuget, csharp
Published: 2020-06-21 17:42:09

|                    Capítulos                   |
|------------------------------------------------|
| [#00 - Instalação e compilador C#](https://dev.to/dannrocha/meus-primeiros-passos-como-c-e-mono-2ao1)           |
| [#01 - Sistema de build e importação de pacotes](https://dev.to/dannrocha/primeiros-passos-com-c-e-o-mono-01-448i) |
| #02 - Configurando ambiente de desenvolvimento |

***Esse post é mais um lembrete***. [Depois de verificar como compilar arquivos C# e como referenciar bibliotecas pelo terminal](https://dev.to/dannrocha/meus-primeiros-passos-como-c-e-mono-2ao1), comecei a procurar como facilitar a compilação e importação de módulos de terceiros. Primeiro dei uma olhada no make e Makefile, mas não é o padrão de projetos C#. Já sabia que muitos projetos usavam um arquivo de extensão: "extensão da linguagem" + "proj", comecei a fuçar a internet procurando pela documentação desse tipo arquivo de projeto, encontrei na documentação da Microsoft [csproj](https://docs.microsoft.com/pt-br/dotnet/core/tools/csproj), [MSBuild](https://docs.microsoft.com/pt-br/visualstudio/msbuild/msbuild?view=vs-2019), [Tutorial Microsoft para um arquivo de projeto do Zero](https://docs.microsoft.com/pt-br/visualstudio/msbuild/walkthrough-creating-an-msbuild-project-file-from-scratch?view=vs-2019).

## Criando um arquivo simples de projeto
* Arvore de diretórios:
```
.
├── main.cs
└── main.csproj
```
Conteúdo dos arquivos
* main.cs

```csharp
using System;

namespace App {
	class Root {
		static void Main(string[] args){
			Console.WriteLine("Ola Mundo csproj");
		}
	}
}
```

* main.csproj
```xml
<?xml version="1.0"?>
<Project>
	<ItemGroup>
		<Reference Include="System" />
	</ItemGroup>
	<ItemGroup>
		<Compile Include="main.cs" />
	</ItemGroup>
	<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
</Project>

```

### Compilando
Vamos usar o [Microsoft Build Engine](https://docs.microsoft.com/pt-br/visualstudio/msbuild/msbuild?view=vs-2019), o MSBuild, mas uma pergunta pode surgir: O mono não fornece um Build Engine? E a resposta é sim, o xbuild, mas esta depreciado e nas versões futuras está previsto para ser removido, ao chamar o xbuild no terminal é emitido a seguinte mensagem: ***">>>> xbuild tool is deprecated and will be removed in future updates, use msbuild instead <<<<"***. Por isso vamos usar o MSBuild.

#### Comando
```
msbuild
```

Se houver mais de um ".csproj" ou ".proj" no diretório de chamada do msbuild, o arquivo de projeto especifico deve ser passado como parâmetro.

```
msbuild outro.csproj
```
Depois de executar o programa msbuild, será gerado o arquivo ***bin*** e ***obj***, seu programa compilado estará em bin.

#### Saída do comando msbuid
![Saída do comando msbuid](https://uploaddeimagens.com.br/images/002/584/940/original/screen.png?1586710734)

### Vamos analisar o ".csproj"
Você pode verificar que o arquivo de projeto está bem "anêmico", escrevi desse modo pra facilitar o meu entendimento, porque é a primeira vez que uso um ***xml***, achei bem simples o entendimento do xml, porque funciona com a estrutura chave, valor e atributos, e é bem semelhante ao HTML.
* [**<*Project*>**](https://docs.microsoft.com/en-us/visualstudio/msbuild/project-element-msbuild?view=vs-2019)
É o tag/nó principal e obrigatório do projeto e ele irá conter as configurações do seu projeto
* [**<*ItemGroup*>**](https://docs.microsoft.com/en-us/visualstudio/msbuild/itemgroup-element-msbuild?view=vs-2019)
Grupo que irá receber os itens de configuração, vocẽ pode inserir quantos ```ItemGrop``` que desejar e que faça sentido a separação dos grupos. Você pode separar um ```ItemGrop``` para bibliotecas de terceiros e outro para suas bibliotecas, e outro pra bibliotecas padrão. No exemplo contém dois ```ItemGrop```, um para referenciar a biblioteca padrão e outro para referenciar os arquivos de compilação feitas pelo usuário.

* [**<*Import*>**](https://docs.microsoft.com/en-us/visualstudio/msbuild/import-element-msbuild?view=vs-2019)
Importa o conteúdo de um arquivo de projeto para outro arquivo de projeto. A propriedade ```$(MSBuildToolsPath)``` é o conjunto ferramentas que especifica o caminho das ferramentas do .NET.

[Mais informações](https://docs.microsoft.com/en-us/visualstudio/msbuild/msbuild-project-file-schema-reference?view=vs-2019)

## Pacotes [NuGet](https://www.nuget.org/)
NuGet é o gerenciador de pacotes do .NET, mas vamos obter apenas os pacotes do seu repositório. Como já sabemos um pouco como o arquivo de projeto funciona, podemos agora usar pacotes de terceiros disponíveis no NuGet.

Eu vou utilizar o pacote [***System.Data.SQLite.Core***](https://www.nuget.org/packages/System.Data.SQLite/), mas ele não é necessário pra utilizar o SQLite no Mono, porque o Mono disponibiliza a biblioteca ***Mono.Data.Sqlite***. Lembrando que esse modo de importação pode ser usado em qualquer pacote disponível no NuGet.

Vamos obter a referencia do pacote no NuGet.
* Acesse o [site](https://www.nuget.org/)
* Pesquise o nome do pacote: ***System.Data.SQLite***

#### Na pagina do pacote
![screenshot 1](https://uploaddeimagens.com.br/images/002/589/138/original/Captura_de_tela_de_2020-04-14_16-29-14.png?1586892822)

Observe a seção marcada com um retângulo vermelho, há quatro modos de importar o pacote para seu projeto. Vamos usar o modo de ***PackageReference***

![screenshot 1](https://uploaddeimagens.com.br/images/002/589/182/original/Captura_de_tela_de_2020-04-14_16-41-21.png?1586893473)

Crie um ***ItemGroup*** e adicione suas referencias dos pacotes do NuGet. O arquivo de projeto ficará assim:

```xml
<?xml version="1.0"?>
<Project>

	<!-- Referências para os pacotes standard -->
    <ItemGroup>
    	<Reference Include="System" />
        <Reference Include="System.Data" />
    </ItemGroup>
    
	<!-- Pacotes do NuGet -->
	<ItemGroup>
	    <PackageReference Include="System.Data.SQLite" Version="1.0.113.1" />
	</ItemGroup>

    <!-- Arquivos do projeto -->
    <ItemGroup>
    	<Compile Include="database/sqlite.cs" />
        <Compile Include="app.cs" />
    </ItemGroup>

    <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />

</Project>

```

É bastante intuitiva o arquivo de projeto. Para obter localmente a biblioteca do  NuGet, use o comando ***msbuild -restore***.

A Microsoft possui uma documentação muito boa e podemos aprender muito com ela. Se você usa uma IDE, ela faz tudo isso e muito mais configurações no seu projeto, mas como o objetivo é aprendizagem, então vale apena usar os programas que estão automatizados por baixo dos panos da IDE.