- Estes arquivos foram criados pelos comandos que você colou no terminal.
- O primeiro comando cria um projeto do tipo webapi com o nome Biblioteca.WebApi. O segundo comando cria uma solução com o nome Biblioteca.
- O terceiro comando adiciona o projeto Biblioteca.WebApi à solução Biblioteca.
-
- No dotnet, um arquivo de solução é um arquivo com extensão .sln que define uma coleção de projetos. Este arquivo é o ponto de entrada utilizado pela IDE para navegar pelo seu código e disponibilizar - as suas ferramentas, como o intellisense e o debugger. -
+- Uma solução pode ter vários projetos, e é bem comum ver aplicações em dotnet que utilizam pelo menos dois. Mas não precisamos nos preocupar com isso agora. Apenas devemos criar uma solução para - fazer o VSCode ler o projeto corretamente. -
++ 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. +
-- -
\ No newline at end of file +
+ Os arquivos com extensão .cs são arquivos de código fonte em C#. Há um arquivo Program.cs que foi gerado automaticamente na criação do projeto, e que é o ponto de entrada 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 public static void main(String[]) do Java, ou o int main() do C).
+ Além do Program.cs, você poderá estruturar o projeto criando vários arquivos .cs, cada um com classes diferentes.
+
+ Já os arquivos .sln e .csproj definem, respectivamente, a solução e o arquivo de definição do projeto.
+
+ Há diversos arquivos com extensão .json. Estes são arquivos de configuração utilizados para fins diversos, a depender do arquivo.
+
+ Os diretórios bin/ e obj/ são criados automaticamente quando você compila o projeto (por exemplo, quando você executa o projeto pela IDE, ou através do comando dotnet run).
+ Por serem gerados automaticamente, estes diretórios podem ser apagados port você a qualquer momento.
+
+ Vamos analisar com mais detalhes alguns destes arquivos base que foram gerados automaticamente: +
+ ++ Este é o arquivo de solução. Uma solução é um "agrupamento de um ou mais projetos que trabalham juntos para criar uma aplicação". +
+ +
+ É bem comum vermos aplicações em .NET que utilizam dois ou mais projetos. Por exemplo, poderíamos criar um projeto Biblioteca.Core que teria toda a lógica da aplicação, um Biblioteca.WebApi que iria expor as APIs, e por fim um Biblioteca.Tests 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 à Biblioteca/Biblioteca.csproj.
+
+ Este arquivo define um projeto do .NET. Ele é escrito em uma sintaxe semelhante à do XML. Nele, variáveis sobre o projeto 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. +
+ +{`
+
+ net9.0
+ enable
+ enable
+
+
+
+
+
+`}
+ 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
+ Biblioteca.Core.csproj, Biblioteca.WebApi.csproj e Biblioteca.Tests.csproj. Por sua vez, o arquivo Biblioteca.sln teria
+ uma referência a cada um deles. Desta forma, teríamos uma solução, com três projetos.
+
+ Este arquivo é um JSON que contém algumas configurações que definem o ambiente em que o projeto será executado. +
+ +{`{
+ "$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"
+ }
+ }
+ }
+}`}
+ De todas estas configurações definidas neste arquivo, a mais importante e que devemos saber é a definição da porta em que a aplicação irá escutar as requisições.
+ Esta configuração é definida nas linhas "applicationUrl": "http://localhost:5000" e "applicationUrl": "https://localhost:7223;http://localhost:5000".
+
+ 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. +
+ + ++ Estes são arquivos JSON onde você pode adicionar variáveis de configuração que podem ser acessadas via código (por exemplo, chaves de conexão com banco de dados). +
+ +
+ Tanto appsettings.json quanto appsettings.Development.json tem exatamente o mesmo propósito, a diferença é que appsettings.Development.json é lido apenas quando a aplicação está no ambiente de desenvolvimento (Development), e as configurações que estão nele sobrescrevem as
+ que estão também presentes em appsettings.json (por exemplo, se nos dois arquivos há a configuração Connection String, o valor que está definido em appsettings.Development.json 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).
+
+ Nós não conseguiremos + enxergar esta diferença durante a escrita do nosso projeto, já que apenas estaremos no ambiente de desenvolvimento. Portanto, tanto faz se colocarmos nossas variáveis em um arquivo ou no outro. +
+ +{`{
+ "Logging": {
+ "LogLevel": {
+ "Default": "Information",
+ "Microsoft.AspNetCore": "Warning"
+ }
+ },
+ "AllowedHosts": "*"
+}`}
+ Todos os arquivos de configuração que vimos até aqui (Biblioteca.sln, Biblioteca.csproj e launchSettings.json) não precisam de nenhuma alteração da nossa parte, então nunca os editaremos. Já o appsettings.json será editado por nós,
+ futuramente, para configurarmos algumas variáveis para o acesso ao nosso banco de dados.
+
Enfim, um arquivo do C#. O Program.cs, como dito anteriormente, é o ponto de entrada da aplicação.
{`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();
+
+...`}+ 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 escopo que definimos anteriormente. +
+