.Net Core 8 - Parte 3: Templates de projetos para .Net Core, criando uma aplicação, analisando sua estrutura e execução

Importante: Neste artigo serão apresentados os modelos de projetos do .Net Core. Você encontrará aqui uma série de artigos do CLI do .Net, onde iremos explorar não apenas a criação de projetos através de um template, como também, utilizar os demais recursos do CLI, como por exemplo, adicionar referências de projetos, adicionar arquivos sln ou instalar um pacote via nuget. Então não fique de fora e confira também a nossa trilha do CLI do .Net!

Neste artigo vamos conhecer os modelos de projetos do .Net Core e como eles facilitam a vida do desenvolvedor(a) além de criar uma aplicação web via CLI e analisar toda sua estrutura, assim como sua execução “subida”.

Como destacado na observação acima, vamos apresentar de forma mais “expressa” os modelos de projetos disponibilizados para .Net Core. As demais interações com o CLI do .Net Core serão abordados em sua devida trilha.

Inicialmente, temos de verificar a instalação do .Net Core em sua estação de trabalho. Se você chegou até aqui, isso já é um sinal de sucesso, mas vamos conferir a versão do .Net Core instalada através do comando abaixo:

dotnet --version

Teremos um resultado semelhante ao abaixo, apresentando a versão instalada:

Para verificar os templates possíveis, o comando abaixo pode ser utilizado

dotnet new list

Teremos um resultado semelhante ao abaixo, mas não igual, pois irá depender de quais recursos e versões instaladas:

Alguns modelos de projeto padrão comuns do ASP.NET Core incluem:

• web ASP.NET Core Vazio (Empty): Um modelo de projeto vazio para criar um aplicativo ASP.NET Core. Este modelo não contém nenhum conteúdo de exemplo.

• blazor Blazor Web App: Um modelo de projeto para criar um aplicativo Web Blazor que oferece suporte à renderização do lado do servidor e à interatividade do cliente. Este modelo pode ser usado para aplicativos da web com interfaces de usuário (UIs) dinâmicas e avançadas.

• webapi API Web ASP.NET Core: Um modelo de projeto para criar uma API Web RESTful usando controladores ASP.NET Core ou APIs mínimas, com suporte opcional para OpenAPI e autenticação.

• grpc ASP.NET Core gRPC Services: Um modelo de projeto para criar um serviço gRPC usando ASP.NET Core.

Customizando opções de um template

Todos os modelos de projeto .NET oferecem opções de personalização para adaptar o projeto gerado às necessidades específicas e estendê-lo com serviços adicionais. Por exemplo, você pode adicionar o Entity Framework Core para acesso ao banco de dados, autenticação, OpenAPI, cache, logging e muito mais, permitindo que o aplicativo atenda efetivamente a requisitos específicos.

Para visualizar todas as opções de personalização de um modelo específico, use o comando abaixo substituindo pelo nome do modelo que você deseja explorar:

dotnet new <template-name> --help

Vamos verificar como seria o help em uma criação de uma webapi.

dotnet new webapi --help

Teremos um resultado semelhante ao abaixo:

Criando uma aplicação .Net Core

Para criarmos uma aplicação de uma forma diferente da apresentada na trilha de CLI, vamos executar os passos abaixo para a criação de uma aplicação web.

• Acesse sua pasta de repositórios e utilize o comando abaixo para a criação da aplicação. Teremos um resultado semelhante ao da imagem abaixo do comando:

dotnet new web -o MinhaAppWeb

Vamos entender melhor o comando:

• dotnet new: um comando CLI do .NET para criar vários artefatos de desenvolvimento .NET com base em modelos como projetos, soluções, bibliotecas, configuração e outros arquivos especializados.

• web: Um modelo de projeto usado para criar um projeto web vazio do ASP.NET Core, sem conteúdo de exemplo.

• -o: A opção de saída especifica o diretório onde o novo projeto é criado: Se o diretório não existir, a CLI do .NET o criará. O diretório onde o projeto é criado serve como nome padrão do projeto, namespace e nome do assembly (o nome da saída compilada). E por fim, Se a opção de saída -o <directory> não for usada, o diretório atual será usado.

Examinando a estrutura do projeto

Para facilitar a visualização da estrutura do projeto, assim como seus arquivos, vamos abrir o mesmo em sua UI de preferência. Para esta demonstração, estarei utilizando o visual studio code.

As próximas sessões irão demonstrar um pouco mais a fundo tudo o que foi construído pelo template.

O arquivo MinhaAppWeb.csproj

O arquivo .csproj é utilizado para:

• Configurar como o projeto realizará o processo de build.

• Especifica qual versão do .NET será utilizada.

• Realizar o gerenciamento das dependências do projeto.

Segue a ilustração de nosso arquivo .csproj demonstrada na imagem abaixo:

A pasta obj

A pasta obj contém arquivos intermediários que são usados ​​pelo sistema de compilação, incluindo arquivos de objetos compilados gerados a partir dos arquivos codificados. A saída final da compilação é colocada em uma pasta bin criada durante o processo de compilação.

Segue ilustração de nossa pasta obj a partir da visualização do visual studio code.

O arquivo Properties/launchSettings.json

O arquivo Properties/launchSettings.json contém dados de configuração sobre como o aplicativo é iniciado durante o desenvolvimento. Essas configurações incluem a propriedade applicationUrl, que especifica o URL raiz que o aplicativo usa, como https://localhost:{port}, onde {port} é um número de porta local aleatório atribuído quando o projeto é criado.

Segue o conteúdo do arquivo launchSettings.json de nossa aplicação criada:

{
  "$schema": "http://json.schemastore.org/launchsettings.json",
  "iisSettings": {
    "windowsAuthentication": false,
    "anonymousAuthentication": true,
    "iisExpress": {
      "applicationUrl": "http://localhost:13908",
      "sslPort": 44307
    }
  },
  "profiles": {
    "http": {
      "commandName": "Project",
      "dotnetRunMessages": true,
      "launchBrowser": true,
      "applicationUrl": "http://localhost:5153",
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      }
    },
    "https": {
      "commandName": "Project",
      "dotnetRunMessages": true,
      "launchBrowser": true,
      "applicationUrl": "https://localhost:7197;http://localhost:5153",
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      }
    },
    "IIS Express": {
      "commandName": "IISExpress",
      "launchBrowser": true,
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      }
    }
  }
}

O arquivo Program.cs

O arquivo Program.cs serve como ponto de entrada para um aplicativo ASP.NET Core e tem vários propósitos principais, que incluem:

• Configuração do host (Host configuration): Configura o host, incluindo a configuração do servidor web.

• Registro de serviço (Service registration): Adiciona serviços à funcionalidade do aplicativo, como contextos de banco de dados, registro em log e serviços especializados para estruturas específicas.

• Configuração do pipeline de middleware (Middleware pipeline configuration): Define o pipeline de manipulação de solicitações do aplicativo como uma série de instâncias de middleware.

• Configuração do ambiente (Environment configuration): Define configurações específicas do ambiente para desenvolvimento, preparação ou produção.

No novo projeto vazio do ASP.NET Core que criamos, o arquivo Program.cs contém minimamente o seguinte código:

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.MapGet("/", () => "Hello World!");

app.Run();

As seguintes linhas de código neste arquivo criam um WebApplicationBuilder com padrões pré-configurados e compilam o aplicativo:

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

O método app.MapGet() define diretamente um endpoint que lida com solicitações HTTP GET:

app.MapGet("/", () => "Hello World!");

app.MapGet("/"): Define uma rota para a solicitação HTTP GET. O / indica que esta rota responde às solicitações feitas à URL raiz do aplicativo. Por exemplo, http://localhost:{port}/, onde {port} é um número de porta atribuído aleatoriamente no arquivo Properties/launchSettings.json na criação do projeto.

() => "Hello World!": Uma expressão lambda que serve como manipulador de solicitação. Quando uma solicitação GET é feita para o URL raiz, esta expressão lambda é executada e retorna a string “Hello World!”

Executando nossa aplicação criada.

Existem inúmeras formas de executarmos esta aplicação, mas para exemplificar de forma rápida, em nosso terminal (na pasta do projeto que contenha o arquivo .csproj), vamos executar o comando abaixo:

dotnet run

O projeto é compilado, executado e podemos esperar um resultado semelhante ao da imagem abaixo:

Como o número da porta na URL fornecida é definido aleatoriamente na configuração durante a criação do projeto, seu endpoint pode ter um número de porta diferente.

Abra um navegador para o URL gerado em sua própria saída de linha de comando, a resposta do aplicativo Hello World! é exibido, como esperado na imagem abaixo:

Para interromper a sua aplicação, pressione CTRL+C e o processo finalizará.

Como o aplicativo da web é executado / “is served”

Quando o aplicativo é criado e executado, ocorrem as seguintes etapas:

• Construção e configuração (Build and Configuration)

MSBuild é invocado para restaurar dependências e compilar o projeto. MSBuild processa o arquivo de projeto MyWebApp.csproj e compila o código-fonte em um assembly.

O aplicativo lê as definições de configuração, incluindo aquelas especificadas em launchSettings.json para o perfil de inicialização padrão (o primeiro listado).

• Configuração do host (Host Setup)

O método CreateHostBuilder em Program.cs configura o host da web. Por padrão, o WebHostBuilder configura o Kestrel como o servidor web. Kestrel é um servidor web multiplataforma para ASP.NET Core projetado para alto desempenho.

O Kestrel começa a escutar solicitações HTTP recebidas nas URLs configuradas, incluindo HTTPS, se especificado.

• Tratamento de solicitações (Request Handling)

Quando uma solicitação é recebida, o Kestrel a encaminha para o pipeline de middleware do ASP.NET Core.

O pipeline de middleware processa a solicitação por meio de uma série de componentes de middleware, que podem lidar com tarefas como authentication, logging, ou routing.

Se a solicitação corresponder a uma rota definida, o endpoint correspondente será executado. Nesse caso, o endpoint app.MapGet("/", () => "Hello World!") manipula solicitações para o URL raiz e retorna a string Hello World!.

• Resposta (Response)

A resposta, que neste caso é a string “Hello World!”, é enviada de volta através do pipeline de middleware para o Kestrel, que então a envia de volta ao cliente.

Conclusão

Neste artigo abordamos os seguintes tópicos:

• Templates do .Net Core;
• Criaçao de um projeto .Net Core a partir de um template;
• Análise de toda a estrutura do projeto, como pastas, arquivos e “caminhos”;
• Análise de toda construção (build) do projeto, assim como sua execução inicial.

Este artigo ficou com uma carga maior, mais denso e exigirá um pouco mais de atenção e foco em seus estudos. Mas acredito que seja um artigo de extrema importância para qualquer pessoa desenvolvedora, pois conhecer o .Net Core mais profundamente irá lhe proporcionar uma base mais sólida e por consequência, você será uma referência no assunto.

Se você gostou do conteúdo, deixe um comentário ou uma reação para apoiar o projeto! Compartilhe com alguém e ajude a divulgar!

Até a próxima!

[ ]´s Degas.