Como funciona ASP.NET Core

  • 2 minutos

Um aplicativo ASP.NET Core é essencialmente um aplicativo .NET com um arquivo Program.cs que configura os recursos do componente do aplicativo Web de que você precisa e o executa.

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

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

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

app.Run();

Com o código anterior:

  • É configurada uma aplicação Web básica ASP.NET Core que escuta pedidos HTTP GET no URL raiz ("/") e responde com "Hello World!".
  • O aplicativo é inicializado, configura uma única rota e inicia o servidor Web.

Blazor

Você pode criar uma interface do usuário da Web interativa com o ASP.NET Core usando Blazor. Blazor é uma estrutura de interface do usuário da Web baseada em componentes integrada ao ASP.NET Core, usada para criar interfaces do usuário da Web interativas usando HTML, CSS e C#.

Um componente Blazor reutilizável, como o seguinte Counter componente é definido em um arquivo Counter.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:

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

O Counter componente pode ser adicionado a qualquer página da Web no aplicativo adicionando o <Counter /> elemento .

@page "/"

<PageTitle>Home</PageTitle>

<h1>Hello, world!</h1>

<Counter />

APIs

O ASP.NET Core fornece estruturas para criar APIs, serviços gRPC e aplicativos em tempo real com o SignalR para enviar atualizações de dados instantaneamente para os clientes.

API mínima básica:

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

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

app.Run();

Com o código anterior:

  • É configurada uma API mínima que escuta as solicitações HTTP GET no URL /hello e responde com "Hello, World!".
  • O WebApplicationBuilder é usado para configurar o aplicativo.
  • O MapGet método define uma rota e um manipulador para solicitações GET.

Middleware

O ASP.NET Core usa um pipeline de componentes de middleware para lidar com solicitações e respostas HTTP. Essa abordagem modular fornece flexibilidade, permitindo que você personalize e estenda a funcionalidade do seu aplicativo adicionando ou removendo componentes de middleware conforme necessário.

O pipeline de middleware processa solicitações HTTP de maneira sequencial, garantindo que cada componente possa executar sua tarefa designada antes de passar a solicitação para o próximo componente no pipeline.

Adicionando middleware interno no arquivo Program.cs :

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 comuns de middleware foram adicionados:

  • UseHttpsRedirection: Redireciona solicitações HTTP para HTTPS.
  • UseRouting: Permite o roteamento para mapear solicitações para pontos de extremidade.
  • MapStaticAssets: Otimiza a entrega de arquivos estáticos como HTML, CSS, JavaScript, imagens e outros ativos.
  • UseAuthentication: Adiciona recursos de autenticação.
  • UseAuthorization: Adiciona recursos de autorização.
  • app.MapGet: Este é um ponto de extremidade simples para demonstrar que o aplicativo está em execução.

Injeção de Dependências

ASP.NET Core inclui suporte interno para injeção de dependência (DI) para configurar serviços que são usados pelo aplicativo e seus vários componentes de estrutura.

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

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:

  • A DbContext é configurado como um serviço usando injeção de dependência.
  • O WebApplicationBuilder é usado para configurar o aplicativo.
  • O AddDbContext método registra o DbContext com o 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 suporta 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.

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

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

No ficheiro Program.cs:

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 .
  • O WebApplicationBuilder é usado para configurar o aplicativo.
  • O AddDbContext método registra o DbContext com o 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.

Monitorização e diagnóstico

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

  • Métricas integradas: ASP.NET Core inclui métricas internas que rastreiam vários aspetos do desempenho do seu aplicativo, como taxas de solicitação, tempos de resposta e taxas de erro.
  • Estrutura de log flexível: uma estrutura de log flexível é incorporada e suporta vários provedores de log, incluindo console, depuração e fonte de eventos. Isso ajuda na captura de logs detalhados para diagnóstico e monitoramento.
  • Rastreamento: o ASP.NET Core oferece suporte ao rastreamento distribuído, que ajuda a rastrear o fluxo de solicitações em diferentes serviços e componentes. Isso é útil para diagnosticar problemas de desempenho e entender as interações entre as diferentes partes do seu aplicativo.
  • OpenTelemetry: ASP.NET Core integra-se com OpenTelemetry, uma estrutura de observabilidade de código aberto para software nativo da nuvem. O OpenTelemetry fornece APIs e instrumentação padronizadas para coletar métricas, logs e rastreamentos, permitindo que você monitore e diagnostique seus aplicativos de forma mais eficaz.
  • Verificações de integridade: a API de verificações de integridade permite monitorar a integridade do seu aplicativo e suas dependências. Você pode 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 você a coletar e analisar dados de diagnóstico do seu aplicativo.