O arquivo `.csproj` (C# Project) é um dos arquivos mais importantes de um projeto .NET. Ele descreve como o projeto deve ser compilado, quais dependências ele possui, qual versão do .NET utiliza, quais arquivos devem ser incluídos e diversas configurações do projeto.
Pense nele como a "receita de montagem" da sua aplicação.
## Estrutura de um projeto
Um projeto ASP.NET Core pode ter esta estrutura:
```text
MinhaApi
│
├── Controllers
├── Models
├── Services
├── Repositories
├── appsettings.json
├── Program.cs
├── MinhaApi.csproj
├── bin
└── obj
```
Observe que existe apenas um arquivo `.csproj` por projeto (normalmente). Já a solução (`.sln`) pode conter vários projetos, cada um com seu próprio `.csproj`.
---
# Exemplo de um arquivo `.csproj`
```xml
<Project Sdk="Microsoft.NET.Sdk.Web">
<PropertyGroup>
<TargetFramework>net8.0</TargetFramework>
<Nullable>enable</Nullable>
<ImplicitUsings>enable</ImplicitUsings>
</PropertyGroup>
</Project>
```
Vamos entender cada parte.
---
## 1. SDK
```xml
<Project Sdk="Microsoft.NET.Sdk.Web">
```
Define qual tipo de projeto será criado.
Alguns exemplos:
| SDK | Tipo |
| ---------------------------- | ------------------------ |
| Microsoft.NET.Sdk | Biblioteca ou Console |
| Microsoft.NET.Sdk.Web | ASP.NET Core |
| Microsoft.NET.Sdk.Worker | Worker Service |
| Microsoft.NET.Sdk.Razor | Razor Class Library |
---VOU DESLIGAR A LUZ TA CAINDO
PODE
## 2. TargetFramework
```xml
<TargetFramework>net8.0</TargetFramework>
```
Informa qual versão do .NET será utilizada.
Exemplos:
```xml
<TargetFramework>net6.0</TargetFramework>
```
```xml
<TargetFramework>net7.0</TargetFramework>
```
```xml
<TargetFramework>net8.0</TargetFramework>
```
```xml
<TargetFramework>net9.0</TargetFramework>
```
---
## 3. Nullable
```xml
<Nullable>enable</Nullable>
```
Ativa as **Referências Anuláveis (Nullable Reference Types)**.
Sem isso:
```csharp
string nome = null;
```
Não gera aviso.
Com isso ativado:
```csharp
string nome = null;
```
O compilador gera um aviso, incentivando um código mais seguro.
---
## 4. Implicit Usings
```xml
<ImplicitUsings>enable</ImplicitUsings>
```
Evita que você precise escrever vários `using` comuns em todos os arquivos.
Sem:
```csharp
using System;
using System.Collections.Generic;
using System.Linq;
```
Com `ImplicitUsings`, muitos desses namespaces são adicionados automaticamente.
---
# Adicionando pacotes NuGet
Quando você instala um pacote, o `.csproj` é atualizado.
Exemplo:
```xml
<ItemGroup>
<PackageReference Include="Dapper" Version="2.1.35" />
<PackageReference Include="Oracle.ManagedDataAccess.Core" Version="23.6.0" />
</ItemGroup>
```
Esses pacotes serão restaurados automaticamente durante o build.
---
# Referência entre projetos
Imagine a solução:
```text
MinhaSolucao
│
├── API
├── Core
├── Infrastructure
└── Tests
```
A API depende do projeto Core.
No `.csproj` da API:
```xml
<ItemGroup>
<ProjectReference Include="..\Core\Core.csproj" />
</ItemGroup>
```
Assim, não é necessário copiar DLLs manualmente.
---
# Arquivos incluídos no projeto
Você pode incluir arquivos específicos:
```xml
<ItemGroup>
<None Include="README.md" />
</ItemGroup>
```
Ou copiar arquivos para a saída:
```xml
<ItemGroup>
<None Update="appsettings.json">
<CopyToOutputDirectory>Always</CopyToOutputDirectory>
</None>
</ItemGroup>
```
---
# Múltiplos frameworks
É possível compilar para mais de uma versão do .NET:
```xml
<PropertyGroup>
<TargetFrameworks>
net8.0;
net9.0
</TargetFrameworks>
</PropertyGroup>
```
Nesse caso, o build gera saídas para ambas as versões.
---
# Configurações de compilação
Você pode definir propriedades como:
```xml
<PropertyGroup>
<LangVersion>latest</LangVersion>
<TreatWarningsAsErrors>true</TreatWarningsAsErrors>
<GenerateDocumentationFile>true</GenerateDocumentationFile>
</PropertyGroup>
```
Isso permite, por exemplo:
* usar a versão mais recente da linguagem C#;
* tratar avisos como erros;
* gerar documentação XML para IntelliSense.
---
# Como ele participa da compilação?
Quando você executa:
```text
dotnet build
```
ou usa **Build Solution** no Visual Studio, o processo é, em linhas gerais:
```text
.csproj
│
▼
MSBuild
│
▼
Restaura pacotes NuGet
│
▼
Compila os arquivos .cs
│
▼
Gera a pasta obj
│
▼
Gera a pasta bin
```
O MSBuild lê o `.csproj` para saber exatamente **o que** compilar e **como** compilar.
---
# Relação entre `.sln` e `.csproj`
Muitas pessoas confundem esses dois arquivos.
| `.sln` | `.csproj` |
| ----------------------------------- | -------------------------------------- |
| Representa a solução | Representa um projeto |
| Pode conter vários projetos | Representa apenas um projeto |
| Usado pelo Visual Studio para | |
| organizar a solução | Usado pelo MSBuild para compilar |
| Não contém regras de | |
| compilação | Contém todas as configurações de | | | build |
Exemplo:
```text
SistemaFinanceiro.sln
│
├── API
│ └── API.csproj
│
├── Core
│ └── Core.csproj
│
├── Infrastructure
│ └── Infrastructure.csproj
│
└── Tests
└── Tests.csproj
```
Em soluções com múltiplos projetos (API, Domain, Infrastructure e Tests), ele é responsável por definir as dependências entre projetos, os pacotes NuGet utilizados e as configurações de compilação, tornando-se um dos principais arquivos de configuração da aplicação.
