Comment fonctionne ASP.NET Core

  • 2 minutes

Une application ASP.NET Core est essentiellement une application .NET avec un fichier Program.cs qui configure les fonctionnalités des composants d’application web dont vous avez besoin et les exécute.

Le fichier Program.cs de l’application ASP.NET Core le plus simple :

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

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

app.Run();

Avec le code précédent :

  • Une application web de base ASP.NET Core est configurée pour écouter les requêtes HTTP GET à l’URL racine (« / ») et répondre avec « Hello World! ».
  • L’application est initialisée, configure un itinéraire unique et démarre le serveur web.

Blazor

Vous pouvez créer une interface utilisateur web interactive avec ASP.NET Core à l’aide de Blazor. Blazor est une infrastructure d’interface utilisateur web basée sur des composants intégrée à ASP.NET Core, utilisée pour créer des interfaces utilisateur web interactives à l’aide de HTML, CSS et C#.

Un composant Blazor réutilisable, tel que le composant suivant Counter , est défini dans un fichier 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++;
    }
}

Avec le code précédent :

  • Un composant est créé pour afficher un compteur.
  • Le bloc @code contient la logique du composant à l’aide de C#, y compris une méthode pour incrémenter le compteur.
  • La valeur du compteur est affichée et mise à jour chaque fois que le bouton est cliqué.
  • Une approche de composant permet la réutilisation du code dans différentes parties de l’application et offre la possibilité d’être exécutée dans le navigateur ou sur le serveur dans une application Blazor.

Le composant Counter peut être ajouté à n’importe quelle page web de l’application en ajoutant l’élément <Counter />.

@page "/"

<PageTitle>Home</PageTitle>

<h1>Hello, world!</h1>

<Counter />

API

ASP.NET Core fournit des infrastructures pour la création d’API, de services gRPC et d’applications en temps réel avec SignalR pour envoyer (push) instantanément des mises à jour de données aux clients.

API minimale de base :

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

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

app.Run();

Avec le code précédent :

  • Une API minimale est configurée pour écouter les requêtes HTTP GET sur l’URL /hello et répondre avec « Hello, World! ».
  • Le WebApplicationBuilder est utilisé pour configurer l’application.
  • La méthode MapGet définit un itinéraire et un gestionnaire pour les requêtes GET.

Intergiciel

ASP.NET Core utilise un pipeline de composants d’intergiciels pour gérer les requêtes et réponses HTTP. Cette approche modulaire offre une flexibilité, ce qui vous permet de personnaliser et d’étendre les fonctionnalités de votre application en ajoutant ou en supprimant des composants d’intergiciels si nécessaire.

Le pipeline d’intergiciel traite les requêtes HTTP de manière séquentielle, ce qui garantit que chaque composant peut effectuer sa tâche désignée avant de passer la requête au composant suivant dans le pipeline.

Ajout d’un intergiciel intégré dans le fichier 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();

Dans le code précédent, plusieurs composants d’intergiciels courants ont été ajoutés :

  • UseHttpsRedirection: redirige les requêtes HTTP vers HTTPS.
  • UseRouting : permet le routage pour mapper les requêtes aux points de terminaison.
  • MapStaticAssets: optimise la remise de fichiers statiques tels que HTML, CSS, JavaScript, images et autres ressources.
  • UseAuthentication : ajoute les fonctionnalités d’authentification.
  • UseAuthorization : ajoute les fonctionnalités d’autorisation.
  • app.MapGet : il s’agit d’un point de terminaison simple pour démontrer que l’application est en cours d’exécution.

Injection de dépendances

ASP.NET Core inclut une prise en charge intégrée de l’injection de dépendances (DI) pour la configuration des services utilisés par l’application et ses différents composants d’infrastructure.

Par exemple, vous souhaiterez peut-être configurer de manière centralisée un service à l’aide d’une infrastructure comme EntityFramework Core dont d’autres parties de votre application dépendent pour accéder à une base de données. Vous pouvez configurer un contexte de base de données à partir d’EntityFramework Core en tant que service à l’aide de l’injection de dépendances comme suit :

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

Avec le code précédent :

  • Un DbContext est configuré en tant que service à l’aide de l’injection de dépendances.
  • Le WebApplicationBuilder est utilisé pour configurer l’application.
  • La méthode AddDbContext inscrit le DbContext avec le conteneur d’injection de dépendances.
  • La chaîne de connexion est récupérée à partir de la configuration et utilisée pour configurer le contexte de base de données.

Paramétrage

ASP.NET Core prend en charge l’accès aux données de configuration à partir de diverses sources, telles que des fichiers JSON, des variables d’environnement et des arguments de ligne de commande.

Configuration d’une chaîne de connexion dans un fichier appsetting.json :

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

Dans le fichier Program.cs :

var builder = WebApplication.CreateBuilder(args);

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

var app = builder.Build();

app.Run();

Avec le code précédent :

  • La chaîne de connexion est configurée dans le fichier appsettings.json .
  • Le WebApplicationBuilder est utilisé pour configurer l’application.
  • La méthode AddDbContext inscrit le DbContext avec le conteneur d’injection de dépendances.
  • La chaîne de connexion est récupérée à partir de la configuration et utilisée pour configurer le contexte de base de données.

Surveillance et diagnostic

ASP.NET Core fournit une suite complète d’outils permettant de surveiller et de maintenir l’intégrité et le niveau de performance de vos applications. Ces fonctionnalités peuvent être facilement ajoutées à votre application en tant que composants d’intergiciels, intégrant des fonctionnalités spécifiques dans votre projet :

  • Métriques intégrées : ASP.NET Core inclut des métriques intégrées qui suivent différents aspects des performances de votre application, tels que les taux de demande, les temps de réponse et les taux d’erreur.
  • Infrastructure de journalisation flexible : une infrastructure de journalisation flexible est intégrée et prend en charge différents fournisseurs de journalisation, notamment la console, le débogage et la source d’événement. Cela permet de capturer des journaux détaillés pour les diagnostics et la surveillance.
  • Suivi : ASP.NET Core prend en charge le suivi distribué, ce qui vous permet de suivre le flux de requêtes entre différents services et composants. Cela est utile pour diagnostiquer les problèmes de performances et comprendre les interactions entre différentes parties de votre application.
  • OpenTelemetry : ASP.NET Core s’intègre à OpenTelemetry, une infrastructure d’observabilité open source pour les logiciels natifs cloud. OpenTelemetry fournit des API et une instrumentation standardisées pour collecter des indicateurs de performance, des journaux et des suivis, ce qui vous permet de surveiller et de diagnostiquer vos applications plus efficacement.
  • Vérifications d’intégrité : l’API de contrôle d’intégrité vous permet de surveiller l’intégrité de votre application et de ses dépendances. Vous pouvez configurer des contrôles d’intégrité pour signaler l’état de différents composants, tels que les bases de données, les services externes, etc.
  • Outils de diagnostic : ASP.NET Core fournit différents outils de diagnostic, tels que dotnet-trace, dotnet-dump et dotnet-gcdump, qui vous aident à collecter et analyser des données de diagnostic à partir de votre application.