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

Tim Corey

52m 05s

Criar aplicações web é uma habilidade fundamental para os desenvolvedores modernos, e compreender as estruturas subjacentes essenciais do projeto é crucial. Este artigo, inspirado no vídeo de Tim Corey sobre " Introdução à API Web ", explora as complexidades da criação de aplicativos web usando o framework ASP.NET Core .

Seguindo as dicas de Tim, exploraremos como configurar e otimizar sua aplicação web, aproveitando todo o potencial do framework ASP.NET Core para criar páginas web e APIs eficientes e de fácil manutenção. Seja você um iniciante em desenvolvimento web ou esteja buscando aprimorar suas habilidades, este guia o ajudará a navegar pelas complexidades do desenvolvimento web, fornecendo o conhecimento necessário para criar aplicações web eficazes e de alto desempenho.

Introdução

Tim Corey inicia seu tutorial apresentando o tópico de criação de APIs com .NET Core. Ele enfatiza a importância de compreender os fundamentos de APIs para construir aplicações web robustas e escaláveis.

Tim começa explicando o papel fundamental que as APIs desempenham no desenvolvimento de software moderno, facilitando a comunicação entre diferentes frameworks de desenvolvimento web, como o servidor web Blazor e o Blazor WebAssembly. Até mesmo o tipo de projeto subjacente das Razor Pages é o ASP.NET Core , permitindo a integração perfeita de várias funcionalidades em múltiplos projetos para a criação de aplicativos web.

Criando um projeto de API Web ASP.NET Core

Para começar, Tim Corey demonstra como configurar um novo projeto de API Web ASP.NET Core . Aqui estão os passos descritos em seu vídeo:

1. Abra o Visual Studio : Comece abrindo o instalador do Visual Studio e selecionando a opção para criar um novo projeto.

2. Escolha o modelo de API : Nos modelos de projeto, selecione "ASP.NET Core Web API" e clique em Avançar.

3. Configurar as definições do projeto : Insira o nome do projeto, escolha a localização e o nome da solução.

4. Informações adicionais : Escolha o .NET Framework, selecione o tipo de autenticação e ele recomenda não alterar outras configurações.

5. Criar o projeto : Clique em "Criar" para gerar o projeto com as configurações padrão e o código necessário.

Essa configuração fornece uma base para explorar o desenvolvimento de APIs, com o Visual Studio gerando uma estrutura básica que inclui componentes essenciais como Program.cs, pasta controllers e appsettings.json.

Visão geral do aplicativo de API padrão

Aos 5:57 do vídeo de Tim Corey, ele apresenta uma visão geral do aplicativo de API padrão gerado pelo 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.

O que é uma API?

Aos 11:22, Tim Corey explica o papel fundamental das APIs (Interfaces de Programação de Aplicativos) no desenvolvimento web moderno. Ele enfatiza a importância deles no gerenciamento e na segurança das trocas de dados entre diferentes componentes de software.

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.

Revisão de código de aplicativo web API

Aos 15:21, Tim Corey inicia uma explicação detalhada da estrutura e funcionalidade de um projeto de API ASP.NET Core . A seguir, apresentamos os pontos principais de suas explicações, que são essenciais para o entendimento ao trabalhar com servidores HTTP e tecnologias do lado do servidor durante a criação de aplicativos web de API:

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();

Imports Microsoft.AspNetCore.Builder
Imports Microsoft.Extensions.DependencyInjection
Imports Microsoft.Extensions.Hosting

Dim 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()

Dim app = builder.Build()

' Configure the HTTP request pipeline.
If app.Environment.IsDevelopment() Then
    app.UseSwagger()
    app.UseSwaggerUI()
End If

app.UseHttpsRedirection()

app.UseAuthorization()

app.MapControllers()

app.Run()

Imports Microsoft.AspNetCore.Builder
Imports Microsoft.Extensions.DependencyInjection
Imports Microsoft.Extensions.Hosting

Dim 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()

Dim app = builder.Build()

' Configure the HTTP request pipeline.
If app.Environment.IsDevelopment() Then
    app.UseSwagger()
    app.UseSwaggerUI()
End If

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"
      }
    }
  }
}

{
  "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 explora WeatherForecastController.cs, destacando a configuração de rota. 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; }
}

Imports Microsoft.AspNetCore.Mvc

<ApiController>
<Route("[controller]")>
Public Class WeatherForecastController
    Inherits ControllerBase

    Private Shared ReadOnly Summaries As String() = New String() _
        {"Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching"}

    Private ReadOnly _logger As ILogger(Of WeatherForecastController)

    Public Sub New(logger As ILogger(Of WeatherForecastController))
        _logger = logger
    End Sub

    <HttpGet>
    Public Function [Get]() As IEnumerable(Of WeatherForecast)
        Return Enumerable.Range(1, 5).Select(Function(index) New WeatherForecast With {
            .Date = DateTime.Now.AddDays(index),
            .TemperatureC = Random.Shared.Next(-20, 55),
            .Summary = Summaries(Random.Shared.Next(Summaries.Length))
        }).ToArray()
    End Function
End Class

Public Class WeatherForecast
    Public Property [Date] As DateTime

    Public Property TemperatureC As Integer

    Public Property Summary As String
End Class

Imports Microsoft.AspNetCore.Mvc

<ApiController>
<Route("[controller]")>
Public Class WeatherForecastController
    Inherits ControllerBase

    Private Shared ReadOnly Summaries As String() = New String() _
        {"Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching"}

    Private ReadOnly _logger As ILogger(Of WeatherForecastController)

    Public Sub New(logger As ILogger(Of WeatherForecastController))
        _logger = logger
    End Sub

    <HttpGet>
    Public Function [Get]() As IEnumerable(Of WeatherForecast)
        Return Enumerable.Range(1, 5).Select(Function(index) New WeatherForecast With {
            .Date = DateTime.Now.AddDays(index),
            .TemperatureC = Random.Shared.Next(-20, 55),
            .Summary = Summaries(Random.Shared.Next(Summaries.Length))
        }).ToArray()
    End Function
End Class

Public Class WeatherForecast
    Public Property [Date] As DateTime

    Public Property TemperatureC As Integer

    Public Property Summary As String
End Class

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.

Criando um controlador de API

Tim demonstra o processo de criação de um controlador de API:

1. Adicionando um Controlador : Clique com o botão direito do mouse na pasta "Controladores" e selecione "Adicionar > Controlador".

2. Selecionando o Controlador de API : Selecione "Controlador de API - Vazio" e forneça um nome para o controlador.

3. Definição de ações : Implemente ações dentro do controlador para lidar com diferentes requisições HTTP. Tim fornece exemplos de código que mostram como definir os métodos GET, POST, PUT e DELETE. Para obter o código detalhado, consulte o vídeo a partir de 26:25.

Esta demonstração prática ajuda os desenvolvedores a entender como criar e configurar controladores de API para lidar com vários tipos de solicitações.

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();

Imports Microsoft.AspNetCore.Builder
Imports Microsoft.Extensions.Hosting

Dim builder = WebApplication.CreateBuilder(args)
Dim app = builder.Build()

app.MapGet("/", Function() "Hello World!")

app.Run()

Imports Microsoft.AspNetCore.Builder
Imports Microsoft.Extensions.Hosting

Dim builder = WebApplication.CreateBuilder(args)
Dim app = builder.Build()

app.MapGet("/", Function() "Hello World!")

app.Run()

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

Por que a API minimalista?

Tim discute os benefícios das APIs mínimas:

1. Criar novo projeto : Tim cria um novo projeto de API Web, mas desta vez, nas informações adicionais, ele desmarcou a opção "Usar controladores". Isso permite a criação de projetos que utilizam APIs mínimas.

2. Redução de código repetitivo : APIs minimalistas reduzem a quantidade de código repetitivo, eliminando a necessidade de controladores e configurações de roteamento adicionais.

3. Simplicidade : Eles oferecem uma abordagem mais direta para APIs simples, facilitando a compreensão e a manutenção do código.

4. Microsserviços : APIs minimalistas são particularmente úteis para microsserviços, onde a API precisa executar um conjunto limitado de ações e não requer o conjunto completo de recursos dos controladores tradicionais.

Tim reconhece que, embora as APIs minimalistas sejam benéficas para certos cenários, os controladores tradicionais podem ser mais apropriados para aplicações maiores ou mais complexas.

Melhores Práticas, Resumo e Considerações Finais

Tim Corey conclui seu tutorial com as melhores práticas para o desenvolvimento de APIs:

1. Separação de Preocupações: Evite colocar lógica de negócio diretamente em Program.cs ou ações do controlador. Em vez disso, mova a lógica para bibliotecas de classes ou serviços separados para manter a organização do código e aderir aos princípios SOLID.

2. API como Interface de Usuário : Trate as APIs como uma interface de usuário, priorizando sua intuição e boa documentação. Tim enfatiza a importância de uma documentação clara e de um design de API eficaz.

3. Swagger e Documentação : Utilize o Swagger para documentação e controle de versão da API. Tim explica como os comentários XML no código podem ser usados ​​para gerar documentação detalhada da API.

4. Considerações adicionais : Considere o uso de cache, limitação de taxa e outros fatores para melhorar o desempenho e a segurança da API.

Tim incentiva os desenvolvedores a explorarem diferentes tipos de projetos e ferramentas, enfatizando a importância de compreender as APIs e seu papel no desenvolvimento de software moderno.

Conclusão

O vídeo de Tim Corey oferece um guia completo sobre como criar e gerenciar APIs no ASP.NET Core, abordando as abordagens RESTful e Minimal API. Suas ideias não apenas ajudam os desenvolvedores a compreender os fundamentos do design de APIs, mas também oferecem conselhos práticos para a implementação de soluções eficazes.

Para tutoriais e informações mais detalhadas sobre C# e outros tipos de projetos, visite o canal do Tim Corey no YouTube, IAmTimCorey .