Ler em inglês

Como funciona o ASP.NET

100 XP
  • 2 minutos

Um aplicativo ASP.NET Core é essencialmente um aplicativo .NET com um arquivo Program.cs que configura os recursos de componente do aplicativo Web necessários e o mantém em execução.

O arquivo Program.cs mais básico do aplicativo ASP.NET Core:

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

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

app.Run();

Com o código anterior:

  • Um aplicativo Web ASP.NET Core básico é configurado para receber solicitações HTTP GET na URL raiz ("/") e responder com "Olá, Mundo!".
  • Ele é inicializado, configura uma única rota e inicia o servidor Web.

Blazor

É possível criar uma interface do usuário da Web interativa com o ASP.NET Core usando o Blazor. O Blazor é uma estrutura da IU da Web baseada em componente e integrada ao ASP.NET Core que é usada para criar UIs da Web interativas usando HTML, CSS e C#.

Um componente reutilizável do Blazor, como o seguinte componente Counter, é definido em um arquivo Counter.razor:

razor 
@page "/counter"
@rendermode InteractiveServer

<PageTitle>Counter</PageTitle>

<h1>Counter</h1>

<p role="status">Current count: @currentCount</p>

<button class="btn btn-primary" @onclick="IncrementCount">Click me</button>

@code {
    private int currentCount = 0;

    private void IncrementCount()
    {
        currentCount++;
    }
}

Com o código anterior:

  • Um componente é criado e exibe um contador.
  • O bloco @code contém a lógica do componente em C#, incluindo um método para incrementar o contador.
  • O valor do contador é exibido e atualizado sempre que o botão é clicado.
  • Uma abordagem de componente permite a reutilização do código em diferentes partes do aplicativo e oferece a flexibilidade de execução no navegador ou no servidor em um aplicativo Blazor.

O componente Counter pode ser adicionado a qualquer página da Web no aplicativo por meio da adição do elemento <Counter />.

razor 
@page "/"

<PageTitle>Home</PageTitle>

<h1>Hello, world!</h1>

<Counter />

APIs

O ASP.NET Core fornece estruturas para a criação de APIs, serviços gRPC e aplicativos em tempo real com o SignalR para o envio instantâneo de atualizações de dados aos clientes.

API básica mínima:

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

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

app.Run();

Com o código anterior:

  • Uma API mínima é configurada para receber solicitações HTTP GET na URL /hello e responder com "Olá, Mundo!".
  • WebApplicationBuilder é usado para configurar o aplicativo.
  • O método MapGet define uma rota e um manipulador para solicitações GET.

Middleware

O ASP.NET Core usa um pipeline de componentes de middleware para processar solicitações e respostas HTTP. Essa abordagem modular fornece flexibilidade e permite personalizar e estender a funcionalidade do aplicativo adicionando ou removendo componentes de middleware conforme necessário.

O pipeline de middleware processa solicitações HTTP de maneira sequencial e garante que cada componente possa executar a tarefa designada antes de enviar a solicitação ao próximo componente no pipeline.

Adição do middleware interno ao arquivo Program.cs:

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

app.UseHttpsRedirection();

app.UseRouting();

app.MapStaticAssets();

app.UseAuthentication();

app.UseAuthorization();

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

app.Run();

No código anterior, vários componentes de middleware comuns foram adicionados:

  • UseHttpsRedirection: redireciona solicitações HTTP para HTTPS.
  • UseRouting: habilita o roteamento para a realização do mapeamento de solicitações para pontos de extremidade.
  • MapStaticAssets: otimiza a entrega de arquivos estáticos, como HTML, CSS, JavaScript, imagens e outros ativos.
  • UseAuthentication: adiciona funcionalidades de autenticação.
  • UseAuthorization: adiciona funcionalidades de autorização.
  • app.MapGet: Esse é um ponto de extremidade simples para demonstrar que o aplicativo está em execução.

Injeção de dependência

O ASP.NET Core inclui suporte interno para DI (injeção de dependência), a fim de configurar serviços usados pelo aplicativo e vários componentes de estrutura associados.

Por exemplo, é possível que você queira configurar centralmente um serviço usando uma estrutura como o EntityFramework Core da qual outras partes do aplicativo dependem para acessar um banco de dados. Você pode configurar um contexto de banco de dados no EntityFramework Core como um serviço usando a injeção de dependência da seguinte maneira:

C# 
public class MyDbContext : DbContext
{
    public MyDbContext(DbContextOptions<MyDbContext> options) : base(options) { }
    
    public DbSet<Product> Products { get; set; } = default!;
}

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddDbContext<MyDbContext>(options =>
    options.UseSqlServer(builder.Configuration.GetConnectionString("DefaultConnection")));

var app = builder.Build();

app.Run();

Com o código anterior:

  • DbContext é configurado como um serviço por meio da injeção de dependência.
  • WebApplicationBuilder é usado para configurar o aplicativo.
  • O método AddDbContext registra DbContext no contêiner de injeção de dependência.
  • A cadeia de conexão é recuperada da configuração e usada para configurar o contexto do banco de dados.

Configuração

O ASP.NET Core é compatível com o acesso a dados de configuração de uma variedade de fontes, como arquivos JSON, variáveis de ambiente e argumentos de linha de comando.

Configuração de uma cadeia de conexão em um arquivo appsetting.json:

JSON 
{
  "ConnectionStrings": {
    "DefaultConnection": "Server=(localdb)\\mssqllocaldb;Database=MyDatabase;Trusted_Connection=True;"
  }
}

No arquivo Program.cs:

C# 
var builder = WebApplication.CreateBuilder(args);

builder.Services.AddDbContext<MyDbContext>(options =>
    options.UseSqlServer(builder.Configuration.GetConnectionString("DefaultConnection")));

var app = builder.Build();

app.Run();

Com o código anterior:

  • A cadeia de conexão é configurada no arquivo appsettings.json.
  • WebApplicationBuilder é usado para configurar o aplicativo.
  • O método AddDbContext registra DbContext no contêiner de injeção de dependência.
  • A cadeia de conexão é recuperada da configuração e usada para configurar o contexto do banco de dados.

Monitoramento e diagnóstico

O ASP.NET Core fornece um conjunto abrangente de ferramentas para monitorar e manter a integridade e o desempenho de aplicativos. Esses recursos podem ser adicionados com facilidade ao aplicativo como componentes de middleware, integrando funcionalidades específicas ao projeto:

  • Métricas internas: O ASP.NET Core inclui métricas internas que monitoram vários aspectos do desempenho do aplicativo, como taxas de solicitação, tempos de resposta e taxas de erro.
  • Estrutura de registros flexível: Há uma estrutura de registros flexível e interna compatível com vários provedores de registro em log, incluindo console, depuração e origem de eventos. Ela ajuda na captura de logs detalhados para diagnóstico e monitoramento.
  • Rastreamento: O ASP.NET Core é compatível com o rastreamento distribuído, que ajuda a monitorar o fluxo de solicitações entre diferentes serviços e componentes. Isso é útil para diagnosticar problemas de desempenho e entender as interações entre diferentes partes do aplicativo.
  • OpenTelemetry: O ASP.NET Core é integrado ao OpenTelemetry, uma estrutura de observabilidade de software livre para softwares nativos de nuvem. O OpenTelemetry fornece APIs padronizadas e instrumentação para a coleta de métricas, logs e rastreamentos, e permite o monitoramento e o diagnóstico mais eficiente de aplicativos.
  • Verificações de integridade: A API de verificações de integridade permite monitorar a integridade do aplicativo e as respectivas dependências. É possível configurar verificações de integridade para relatar o status de vários componentes, como bancos de dados, serviços externos e muito mais.
  • Ferramentas de diagnóstico: O ASP.NET Core fornece várias ferramentas de diagnóstico, como dotnet-trace, dotnet-dump e dotnet-gcdump, que ajudam na coleta e análise de dados de diagnóstico do aplicativo.

Unidade seguinte: Quando usar o ASP.NET Core

Anterior Avançar