Criando uma aplicação web em C# com ASP.NET Core

Executando o aplicativo padrão

Tim começa executando o aplicativo padrão para ilustrar o que os desenvolvedores obtêm imediatamente após a instalação. Após a execução, o projeto compila a API, baixa os pacotes NuGet necessários e inicia uma página da web. Esta configuração inicial demonstra a estrutura básica e as funcionalidades da API sem quaisquer modificações.

Interação com a API

A página web que é aberta utiliza a tecnologia Swagger, agora conhecida como OpenAPI. O Swagger fornece uma interface amigável para interagir com a API. Isso permite que tanto desenvolvedores quanto não desenvolvedores entendam e testem os endpoints da API com facilidade. Essa interface é particularmente útil para visualizar o funcionamento da API e para fins de documentação.

Explorando a Arrogância

O Swagger exibe os endpoints disponíveis na API. Na configuração padrão, um dos endpoints pré-configurados é o endpoint de "previsão do tempo". Ao clicar neste endpoint e usar o recurso "Experimentar", os usuários podem executar a chamada da API e ver a resposta. Esta resposta inclui uma previsão do tempo em formato JSON, demonstrando como os dados são retornados pela API.

Tim, às 8h32, destaca que, embora os dados JSON brutos possam ser difíceis de ler diretamente do navegador, a documentação sobreposta do Swagger torna a leitura muito mais fácil. A documentação fornece informações detalhadas sobre o endpoint, incluindo o método de requisição (GET, POST, etc.), a estrutura dos dados retornados e quaisquer parâmetros necessários.

Documentação JSON e versionamento de API

O Swagger também gera um arquivo JSON, como Tim indica às 9:10, que documenta a API em um formato legível por máquina. Esta documentação é crucial para outras aplicações que precisam interagir com a API, pois descreve os endpoints disponíveis, os esquemas de dados e as respostas esperadas.

Tim, às 9h29, destaca a importância do versionamento em APIs. A configuração padrão inclui um indicador de versão, sugerindo a possibilidade de múltiplas versões da API. O controle de versões é vital para manter a compatibilidade com versões anteriores. Quando alterações na API podem afetar clientes existentes, ter várias versões permite que os desenvolvedores introduzam novos recursos ou alterações sem interromper os usuários atuais.

Finalidade das APIs

Tim destaca que a maioria das aplicações gira em torno de dados — recuperação, manipulação e exibição. As APIs servem como intermediárias entre a interface do usuário e os dados subjacentes, proporcionando um meio seguro e eficiente de acesso aos dados. Essa centralização é crucial por diversos motivos:

1. Segurança : As APIs oferecem uma forma segura de gerenciar o acesso aos dados. Aplicativos móveis e do lado do cliente não devem se conectar diretamente a bancos de dados para evitar a incorporação de credenciais de banco de dados no código do cliente, o que representa riscos de segurança significativos.

2. Abstração : As APIs abstraem a camada de dados da interface do usuário, permitindo que diferentes aplicativos cliente (aplicativos móveis, aplicativos web, aplicativos de desktop) interajam com a mesma fonte de dados sem expor o banco de dados ou suas credenciais.

Versatilidade em diferentes contextos

Tim observa que as APIs não se limitam a frameworks ou linguagens específicas. Por exemplo, uma API em C# pode ser acessada por frameworks JavaScript como Angular, React ou Vue, demonstrando as capacidades multiplataforma das APIs.

1. Visão geral do Program.cs

Tim analisa o arquivo Program.cs, observando que ele compila a aplicação web e configura serviços como injeção de dependência para controladores e Swagger (OpenAPI). O código configura os serviços essenciais antes de compilar e executar a aplicação.

using Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.
builder.Services.AddControllers();
// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

var app = builder.Build();

// Configure the HTTP request pipeline.
if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

app.UseHttpsRedirection();

app.UseAuthorization();

app.MapControllers();

app.Run();

using Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.
builder.Services.AddControllers();
// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

var app = builder.Build();

// Configure the HTTP request pipeline.
if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

app.UseHttpsRedirection();

app.UseAuthorization();

app.MapControllers();

app.Run();

2. Configuração do ambiente

Tim explica como as configurações de ambiente são configuradas em launchSettings.json. O ambiente padrão está definido como "Desenvolvimento" para testes locais, habilitando o Swagger. Em produção, o Swagger geralmente é desativado por motivos de segurança, mas pode ser ativado removendo a verificação de desenvolvimento.

{
  "profiles": {
    "IIS Express": {
      "commandName": "IISExpress",
      "launchBrowser": true,
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      }
    },
    "WebApplication": {
      "commandName": "Project",
      "launchBrowser": true,
      "applicationUrl": "https://localhost:5001;http://localhost:5000",
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      }
    }
  }
}

3. Redirecionamento HTTPS e Controladores

Tim destaca o redirecionamento HTTPS e o mapeamento de controladores. Essa configuração garante que as rotas da API estejam configuradas corretamente. Ele prefere usar o prefixo "api" para maior clareza nas rotas de requisição e resposta HTTP, que podem ser modificadas para garantir que os caminhos da API sejam distintos.

4. Controlador de Previsão do Tempo

Tim aprofunda no WeatherForecastController.cs, destacando a configuração de rotas. A rota padrão é /weatherforecast, que pode ser modificada para incluir um prefixo "api". O controlador utiliza o método HTTP GET para recuperar dados, que podem ser acessados ​​através da rota especificada.

using Microsoft.AspNetCore.Mvc;

[ApiController]
[Route("[controller]")]
public class WeatherForecastController : ControllerBase
{
    private static readonly string[] Summaries = new[]
    {
        "Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching"
    };

    private readonly ILogger<WeatherForecastController> _logger;

    public WeatherForecastController(ILogger<WeatherForecastController> logger)
    {
        _logger = logger;
    }

    [HttpGet]
    public IEnumerable<WeatherForecast> Get()
    {
        return Enumerable.Range(1, 5).Select(index => new WeatherForecast
        {
            Date = DateTime.Now.AddDays(index),
            TemperatureC = Random.Shared.Next(-20, 55),
            Summary = Summaries[Random.Shared.Next(Summaries.Length)]
        })
        .ToArray();
    }
}

public class WeatherForecast
{
    public DateTime Date { get; set; }

    public int TemperatureC { get; set; }

    public string? Summary { get; set; }
}

using Microsoft.AspNetCore.Mvc;

[ApiController]
[Route("[controller]")]
public class WeatherForecastController : ControllerBase
{
    private static readonly string[] Summaries = new[]
    {
        "Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching"
    };

    private readonly ILogger<WeatherForecastController> _logger;

    public WeatherForecastController(ILogger<WeatherForecastController> logger)
    {
        _logger = logger;
    }

    [HttpGet]
    public IEnumerable<WeatherForecast> Get()
    {
        return Enumerable.Range(1, 5).Select(index => new WeatherForecast
        {
            Date = DateTime.Now.AddDays(index),
            TemperatureC = Random.Shared.Next(-20, 55),
            Summary = Summaries[Random.Shared.Next(Summaries.Length)]
        })
        .ToArray();
    }
}

public class WeatherForecast
{
    public DateTime Date { get; set; }

    public int TemperatureC { get; set; }

    public string? Summary { get; set; }
}

5. Verbos HTTP e Roteamento

Tim explica como os verbos HTTP (GET, POST, PUT, DELETE) definem os endpoints da API. Para uma requisição GET, o navegador chama o método especificado no controlador. Outros verbos exigem ferramentas como o Postman para testes.

API REST

Tim Corey apresenta o REST (Representational State Transfer) e seus princípios:

1. O que é REST : REST é um estilo arquitetônico para projetar aplicações em rede. Ele se baseia em comunicação sem estado e usa métodos HTTP padrão (GET, POST, PUT, DELETE) para realizar operações.

2. Princípios RESTful : APIs RESTful usam padrões de URL para representar recursos. Por exemplo, /users recupera todos os usuários, enquanto /users/5 recupera um usuário específico com ID 5.

3. Conformidade com REST : Tim observa que alcançar a conformidade total com REST pode ser um desafio, já que REST era originalmente um modelo teórico. No entanto, a adesão aos princípios REST pode levar a APIs mais intuitivas e consistentes.

Tim enfatiza que, embora o objetivo seja a conformidade com o REST, considerações práticas devem orientar o design da API para garantir usabilidade e funcionalidade.

Aplicação de API mínima

Corey apresenta as APIs Mínimas, uma abordagem simplificada para o desenvolvimento de APIs no ASP.NET Core:

1. Configurando APIs mínimas : Tim mostra como criar um projeto de API mínima desmarcando a opção "Usar controladores" ao configurar o projeto.

2. Código Simplificado: APIs mínimas eliminam a necessidade de controladores e atributos de roteamento, permitindo que os desenvolvedores definam endpoints diretamente em Program.cs usando métodos como app.MapGet(), app.MapPost(), etc.

3. Exemplo de código : Tim fornece um exemplo de código onde uma única linha de código define um ponto final. Ele demonstra como mapear uma solicitação GET para um endpoint com configuração mínima.

using Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.Hosting;

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

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

app.Run();

using Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.Hosting;

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

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

app.Run();

APIs minimalistas são projetadas para simplificar o desenvolvimento, especialmente para aplicações menores ou microsserviços.