<script lang="ts"></script>

<svelte:head>
  <title>Estrutura de arquivos</title>
</svelte:head>

<section>
  <h1>Estrutura de arquivos</h1>

  <nav>
    <a href="/">Início</a>
  </nav>

  <p>
    O processo de criação do projeto gera todos os arquivos base que precisamos para começar a escrever uma API. Eles se dividem, basicamente, entre arquivos de configuração, de código fonte, e dos binários resultantes da compilação.
  </p>

  <p>
    Os arquivos com extensão <code>.cs</code> são arquivos de código fonte em <em>C#</em>. Há um arquivo <code>Program.cs</code> que foi gerado automaticamente na criação do projeto, e que é o <em>ponto de entrada</em> da aplicação.
    Ou seja, quando o projeto for executado, o conteúdo deste arquivo será o primeiro a ser executado (é o equivalente ao arquivo que contém <code>public static void main(String[])</code> do Java, ou o <code>int main()</code> do C).
    Além do <code>Program.cs</code>, você poderá estruturar o projeto criando vários arquivos <code>.cs</code>, cada um com classes diferentes.
  </p>

  <p>
    Já os arquivos <code>.sln</code> e <code>.csproj</code> definem, respectivamente, a <a href="#sln">solução</a> e o <a href="#csproj">arquivo de definição do projeto</a>.
  </p>

  <p>
    Há diversos arquivos com extensão <code>.json</code>. Estes são arquivos de configuração utilizados para fins diversos, a depender do arquivo.
  </p>

  <p>
    Os diretórios <code>bin/</code> e <code>obj/</code> são criados automaticamente quando você <em>compila</em> o projeto (por exemplo, quando você executa o projeto pela IDE, ou através do comando <code>dotnet run</code>).
    Por serem gerados automaticamente, estes diretórios podem ser apagados por você a qualquer momento.
  </p>

  <p>
    Vamos analisar com mais detalhes alguns destes arquivos base que foram gerados automaticamente:
  </p>

  <section>
    <h2 id="sln">Biblioteca.sln</h2>

    <p>
      Este é o arquivo de <em>solução</em>. Uma <em>solução</em> é um <a href="https://learn.microsoft.com/pt-br/visualstudio/extensibility/internals/solutions-overview?view=vs-2022" target="_blank">"agrupamento de um ou mais <em>projetos</em> que trabalham juntos para criar uma aplicação"</a>.
    </p>

    <p>
      É bem comum vermos aplicações em .NET que utilizam dois ou mais projetos. Por exemplo, poderíamos criar um projeto <code>Biblioteca.Core</code> que teria toda a lógica da aplicação, um <code>Biblioteca.WebApi</code> que iria expor as APIs, e por fim um <code>Biblioteca.Tests</code> com testes unitários.
      Como estamos trabalhando apenas com um projeto para deixar as coisas mais simples, nosso arquivo de solução somente terá referência à <code>Biblioteca/Biblioteca.csproj</code>.
    </p>
    
    <nav>
      <ul>
        <li>Veja também:</li>
        <li><a href="https://learn.microsoft.com/pt-br/visualstudio/extensibility/internals/solutions-overview?view=vs-2022" target="_blank">Visão geral das soluções</a>.</li>
      </ul>
    </nav>
  </section>

  <section>
    <h2 id="csproj">
      Biblioteca/Biblioteca.csproj
    </h2>

    <p>
      Este arquivo <em>define</em> um projeto do .NET. Ele é escrito em uma sintaxe semelhante à do XML. Nele, variáveis <em>sobre o projeto</em> são configuradas. Por exemplo, a versão do .NET utilizada, opções de análise do compilador, além de referêncas à bibliotecas externas.
    </p>

<pre><code>{`<Project Sdk="Microsoft.NET.Sdk.Web">
  <PropertyGroup>
    <TargetFramework>net9.0</TargetFramework>
    <Nullable>enable</Nullable>
    <ImplicitUsings>enable</ImplicitUsings>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Microsoft.AspNetCore.OpenApi" Version="9.0.2" />
  </ItemGroup>
</Project>
`}</code></pre>

    <p>
      Este arquivo também é utilizado como referência pelo arquivo de solução. Ainda no exemplo dado anteriormente, se tivéssemos criado os três projetos, cada um deles teria, respectivamente, um arquivo
      <code>Biblioteca.Core.csproj</code>, <code>Biblioteca.WebApi.csproj</code> e <code>Biblioteca.Tests.csproj</code>. Por sua vez, o arquivo <code>Biblioteca.sln</code> teria
      uma referência a cada um deles. Desta forma, teríamos uma solução, com três projetos.
    </p>

    <nav>
      <ul>
        <li>Veja também:</li>
        <li><a href="https://learn.microsoft.com/pt-br/aspnet/web-forms/overview/deployment/web-deployment-in-the-enterprise/understanding-the-project-file">Noções básicas sobre o arquivo de projeto</a></li>
      </ul>
    </nav>
  </section>

  <section>

  </section>

  <section>
    <h2 id="launchSettings.json">
      Properties/launchSettings.json
    </h2>

    <p>
      Este arquivo é um <a href="https://developer.mozilla.org/en-US/docs/Learn_web_development/Core/Scripting/JSON" target="_blank">JSON</a> que contém algumas configurações que definem o <em>ambiente em que o projeto será executado</em>.
    </p>

<pre><code>{`{
  "$schema": "https://json.schemastore.org/launchsettings.json",
  "profiles": {
    "http": {
      "commandName": "Project",
      "dotnetRunMessages": true,
      "launchBrowser": false,
      "applicationUrl": "http://localhost:5000",
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      }
    },
    "https": {
      "commandName": "Project",
      "dotnetRunMessages": true,
      "launchBrowser": false,
      "applicationUrl": "https://localhost:7223;http://localhost:5000",
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      }
    }
  }
}`}</code></pre>

    <p>
      De todas estas configurações definidas neste arquivo, a mais importante e que <em>devemos saber</em> é a definição da <em>porta</em> em que a aplicação irá escutar as requisições.
      Esta configuração é definida nas linhas <code>"applicationUrl": "http://localhost:5000"</code> e <code>"applicationUrl": "https://localhost:7223;http://localhost:5000"</code>.
    </p>

    <p>
      Isto significa que a aplicação está configurada para escutar requisições HTTP na porta 5000, e HTTPS na porta 7223. Podemos ignorar a porta HTTPS, já que não a utilizaremos neste material. Porém, tenha em mente qual é a porta que está definida neste arquivo para o protocolo HTTP.
    </p>

    <nav>
      <ul>
        <li>Veja também:</li>
        <li><a href="https://learn.microsoft.com/en-us/aspnet/core/fundamentals/environments?view=aspnetcore-9.0#development-and-launchsettingsjson" target="_blank">Development and launchSettings.json</a></li>
      </ul>
    </nav>
  </section>

  <section>
    <h2>appsettings.json e appsettings.Development.json</h2>

    <p>
      Estes são arquivos <a href="https://developer.mozilla.org/en-US/docs/Learn_web_development/Core/Scripting/JSON" target="_blank">JSON</a> onde você pode adicionar <em>variáveis de configuração</em> que podem ser acessadas via <em>código</em> (por exemplo, chaves de conexão com banco de dados).
    </p>

    <p>
      Tanto <code>appsettings.json</code> quanto <code>appsettings.Development.json</code> tem exatamente o mesmo propósito, a diferença é que <code>appsettings.Development.json</code> é lido <em>apenas</em> quando a aplicação está no ambiente de <em>desenvolvimento (Development)</em>, e as configurações que estão nele sobrescrevem as
      que estão também presentes em <code>appsettings.json</code> (por exemplo, se nos dois arquivos há a configuração <code>Connection String</code>, o valor que está definido em <code>appsettings.Development.json</code> será o valor lido de fato). A separação destes arquivos é realizada para que possamos definir
      valores diferentes para os ambientes de desenvolvimento e de produção (por exemplo, para definir uma chave de banco de dados de teste para o ambiente de desenvolvimento, e uma de um banco de dados de produção para o ambiente de produção).
    </p>

    <p>
      Nós não conseguiremos
      enxergar esta diferença durante a escrita do nosso projeto, já que apenas estaremos no ambiente de <em>desenvolvimento</em>. Portanto, tanto faz se colocarmos nossas variáveis em um arquivo ou no outro.
    </p>

<pre><code>{`{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "AllowedHosts": "*"
}`}</code></pre>

    <p>
      Todos os arquivos de configuração que vimos até aqui (<code>Biblioteca.sln</code>, <code>Biblioteca.csproj</code> e <code>launchSettings.json</code>) não precisam de nenhuma alteração da nossa parte, então nunca os editaremos. Já o <code>appsettings.json</code> será editado por nós,
      futuramente, para configurarmos algumas variáveis para o acesso ao nosso banco de dados.
    </p>

    <nav>
      <ul>
        <li>Veja também:</li>
        <li><a href="https://learn.microsoft.com/pt-br/aspnet/core/fundamentals/configuration/?view=aspnetcore-9.0" target="_blank">Configuração no ASP.NET Core</a></li>
      </ul>
    </nav>
  </section>

  <section>
    <h2>Biblioteca/Program.cs</h2>

    <p>Enfim, um arquivo do C#. O <code>Program.cs</code>, como dito anteriormente, é o <em>ponto de entrada da aplicação</em>.</p>

<pre><code>{`var builder = WebApplication.CreateBuilder(args);

...

var app = builder.Build();

...

app.MapGet("/weatherforecast", () =>
{
    var forecast =  Enumerable.Range(1, 5).Select(index =>
        new WeatherForecast
        (
            DateOnly.FromDateTime(DateTime.Now.AddDays(index)),
            Random.Shared.Next(-20, 55),
            summaries[Random.Shared.Next(summaries.Length)]
        ))
        .ToArray();
    return forecast;
})
.WithName("GetWeatherForecast");

app.Run();

...`}</code></pre>

    <p>
      O conteúdo que foi gerado automaticamente na criação do projeto contém uma configuração inicial de um endpoint de exemplo. Na próxima seção, vamos começar a escrever código para criamos os endpoints para o <a href="/projeto_de_api" target="_blank">escopo que definimos anteriormente</a>.
    </p>
  </section>

  <nav>
    <span>Próximo:</span>
    <a href="/endpoints_1">Criando e executando endpoints</a>
  </nav>
</section>

<style>
  /* section > section {
    margin-top: 50px;
  } */
</style>