De nos jours, un développeur qui souhaite bâtir une application web à la fois rapide, fiable et évolutive se tourne naturellement vers des technologies modernes, capables de répondre aux exigences du web actuel. Parmi les solutions les plus robustes et flexibles, ASP.NET Core, associé au langage C#, occupe une place de choix. Cette plateforme open source, soutenue par Microsoft, s’adresse autant aux projets d’entreprise qu’aux initiatives individuelles ambitieuses.Dans ce guide, nous allons découvrir comment concevoir une application web moderne avec ASP.NET Core, depuis la mise en place de l’environnement de développement jusqu’à l’architecture logicielle, l’intégration des services essentiels et le déploiement. Chaque étape mettra en lumière les bonnes pratiques et les outils incontournables pour un développement web maîtrisé.

Configurer l’environnement de développement et créer le projet d’application Web

Avant d’écrire la moindre ligne de code, il est essentiel de disposer d’un environnement de développement stable, complet et adapté aux exigences des applications web modernes. L’un des grands atouts d’ASP.NET Core est sa compatibilité multiplateforme, ce qui signifie que vous pouvez développer et exécuter votre application aussi bien sur Windows, macOS que sur Linux, sans modification du code. Voici les composants indispensables à installer pour démarrer un projet ASP.NET Core :

• .NET SDK (Software Development Kit) : Version 8.0 ou supérieure. Il inclut le compilateur C#, les bibliothèques du framework .NET, les outils CLI (dotnet) et tout ce qu’il faut pour créer, compiler, exécuter et publier une application ASP.NET Core ;
• Visual Studio (version 2022 ou 2025) ou Visual Studio Code avec les extensions C#. Visual Studio offre un environnement complet avec prise en charge d’ASP.NET, de Razor, du debug pas-à-pas, de Git, du déploiement Azure et bien plus ;
• NuGet : Le gestionnaire de paquets .NET est intégré à l’environnement. Il permet d’ajouter facilement des bibliothèques (packages) tiers ou de Microsoft, comme Entity Framework Core, Serilog ou MediatR.

Une fois ces outils installés et votre environnement prêt, vous pouvez créer une nouvelle application web de deux façons :

Méthode 1 : Via l’interface de Visual Studio

• Ouvrez Visual Studio et cliquez sur « Créer un nouveau projet ».
• Sélectionnez « Application Web ASP.NET Core ».
• Choisissez la version du framework (.NET 8 ou plus), le type de projet (MVC ou Razor Pages), puis validez.

Cette méthode est idéale pour les développeurs préférant une interface graphique complète, avec une configuration guidée et des options avancées comme l’intégration de l’authentification, du HTTPS, du conteneur Docker ou de la CI/CD.

Méthode 2 : Via la ligne de commande (CLI .NET)

Pour ceux qui privilégient une approche plus directe ou automatisée, le CLI .NET est un outil puissant. Exécutez les commandes suivantes dans un terminal :

dotnet new webapp -n MonAppWeb
cd MonAppWeb
dotnet run

Cette suite de commandes permet de générer un squelette d’application Razor Pages (vous pouvez utiliser mvc à la place de webapp pour un projet MVC). La commande dotnet run lance ensuite le serveur de développement Kestrel intégré, disponible sur http://localhost:5000 par défaut.

Ce que contient le projet généré

Le modèle de base généré par la commande CLI ou Visual Studio comprend :

• Une structure MVC ou Razor Pages : avec les répertoires Pages ou Controllers, Views et Models selon le modèle choisi.
• Des fichiers statiques : répertoire wwwroot contenant CSS, JavaScript, images, favicon, etc.
• Un système de routage intégré : géré via les attributs des contrôleurs ou les conventions dans Program.cs.
• Une configuration multi-environnement : avec des fichiers appsettings.Development.json et appsettings.Production.json permettant d’adapter dynamiquement le comportement de l’application selon le contexte.
• Support HTTPS par défaut : avec un certificat de développement local généré automatiquement.

Les fichiers clés du projet

Voici un aperçu des fichiers essentiels que vous trouverez dans un projet ASP.NET Core typique :

À ce stade, votre application web est opérationnelle. Elle affiche une page d’accueil par défaut avec une structure propre, prête à être enrichie par vos propres vues, modèles, services et composants métiers. Nous allons maintenant voir comment la personnaliser et lui ajouter des fonctionnalités avancées.

Développer les fonctionnalités clés avec le modèle MVC

ASP.NET Core repose sur le pattern Modèle-Vue-Contrôleur (MVC), qui sépare clairement les responsabilités. Voici comment chaque composant interagit :

• Modèle : gère les données et les règles métiers ;
• Vue : responsable de l’affichage (HTML, Razor, etc.) ;
• Contrôleur : traite les requêtes et retourne une réponse ;

Créons un exemple simple de gestion de produits :

1. Le modèle

Le modèle représente les données manipulées dans l’application ainsi que la structure qui permet leur traitement. Dans le cadre d’une application web ASP.NET Core utilisant le modèle MVC, les classes du modèle sont généralement de simples objets C# (POCO pour Plain Old CLR Objects) qui définissent les propriétés correspondant aux entités métier.

Voici un exemple de modèle basique représentant un produit :

public class Produit
{
    public int Id { get; set; }
    public string Nom { get; set; }
    public decimal Prix { get; set; }
}

Cette classe Produit contient trois propriétés :

• Id : une propriété de type int utilisée comme identifiant unique. Dans le cadre de l’utilisation avec Entity Framework Core, cette propriété est automatiquement considérée comme la clé primaire ;
• Nom : une chaîne de caractères (string) représentant le nom du produit. Elle sera généralement soumise à des contraintes de validation côté serveur (longueur minimale, caractères interdits, etc.) ;
• Prix : une valeur décimale (decimal), plus adaptée que float ou double pour représenter des montants financiers, afin d’éviter les imprécisions dues à la virgule flottante.

Cette classe peut être enrichie à l’aide d’annotations de validation issues du namespace System.ComponentModel.DataAnnotations. Par exemple :

using System.ComponentModel.DataAnnotations;

public class Produit
{
    public int Id { get; set; }

    [Required]
    [StringLength(100)]
    public string Nom { get; set; }

    [Range(0.01, 10000.00)]
    public decimal Prix { get; set; }
}

Avec ces annotations :

• [Required] impose que le nom du produit soit renseigné.
• [StringLength(100)] limite le nom à 100 caractères maximum.
• [Range(0.01, 10000.00)] impose que le prix soit compris entre 0,01 € et 10 000 €, ce qui permet de prévenir les valeurs aberrantes.

Ces règles seront automatiquement prises en compte lors de la validation côté serveur, notamment lors de la soumission de formulaires via les vues Razor. Elles peuvent également être utilisées pour générer des messages d’erreur utilisateur clairs et localisés.

2. Le contrôleur

Dans le modèle architectural MVC (Modèle-Vue-Contrôleur), le contrôleur joue un rôle central : il agit comme un intermédiaire entre le modèle (données) et la vue (interface utilisateur). Il reçoit les requêtes HTTP, interagit avec les données (via le modèle), puis retourne une réponse, généralement sous forme de vue ou de redirection. Voici un exemple simple de contrôleur permettant d’afficher une liste de produits et d’en ajouter de nouveaux :

public class ProduitsController : Controller
{
    private static List<Produit> _produits = new();

    public IActionResult Index()
    {
        return View(_produits);
    }

    [HttpPost]
    public IActionResult Ajouter(Produit produit)
    {
        _produits.Add(produit);
        return RedirectToAction("Index");
    }
}

Décomposons les différents éléments de ce contrôleur :

• ProduitsController : Par convention, un contrôleur porte le suffixe Controller et hérite de la classe de base Controller, qui fournit des méthodes utiles comme View(), RedirectToAction() ou ModelState ;
• private static List<Produit> _produits : Ici, nous utilisons une liste statique en mémoire pour stocker temporairement les produits. Dans une application réelle, cette logique serait remplacée par une couche d’accès aux données (par exemple, via Entity Framework Core et une base SQL) ;
• Index() : Cette méthode traite une requête HTTP GET sur l’URL /Produits/Index (ou simplement /Produits si le routage par défaut est utilisé). Elle transmet la liste des produits à la vue Index.cshtml ;
• Ajouter(Produit produit) : Cette méthode gère les requêtes POST issues d’un formulaire. Le framework effectue automatiquement le binding (liaison) entre les champs du formulaire HTML et les propriétés de l’objet Produit grâce à la signature de la méthode. Une fois le produit ajouté à la liste, la méthode redirige vers l’action Index() pour réafficher la liste mise à jour.

Quelques bonnes pratiques à appliquer en production

On peut retenir :

• Remplacer la liste statique par une dépendance injectée vers un service ou un contexte base de données.
• Ajouter une vérification de la validité des données avec ModelState.IsValid avant d’ajouter un objet.
• Utiliser le pattern Repository pour séparer la logique métier de l’accès aux données.
• Ajouter des attributs [ValidateAntiForgeryToken] pour sécuriser les formulaires contre les attaques CSRF.

Voici une version plus proche des standards de production avec validation du modèle :

[HttpPost]
[ValidateAntiForgeryToken]
public IActionResult Ajouter(Produit produit)
{
    if (ModelState.IsValid)
    {
        _produits.Add(produit);
        return RedirectToAction("Index");
    }

    return View("Index", _produits);
}

Dans ce cas, si les données envoyées ne respectent pas les règles de validation définies dans la classe Produit, la page est renvoyée avec les erreurs de validation affichées à l’utilisateur..

3. La vue (Razor)

Dans l’architecture MVC d’ASP.NET Core, la vue est responsable de la présentation des données à l’utilisateur final. Elle est généralement écrite en syntaxe Razor, un moteur de rendu côté serveur développé par Microsoft. Razor permet de combiner du HTML classique avec du code C# de manière fluide, ce qui rend les vues dynamiques et facilement maintenables.

Voici un exemple simple de vue affichant une liste de produits, avec un formulaire permettant d’en ajouter un nouveau :

@model List<Produit>

<h2>Liste des produits</h2>

<ul>
@foreach (var p in Model)
{
    <li>@p.Nom - @p.Prix €</li>
}
</ul>

<form method="post" asp-action="Ajouter">
    <input type="text" name="Nom" placeholder="Nom" />
    <input type="number" name="Prix" placeholder="Prix" step="0.01" />
    <button type="submit">Ajouter</button>
</form>

Décomposons les éléments principaux de cette vue :

• @model List<Produit> : cette directive Razor indique que la vue s’attend à recevoir une liste de produits. Elle permet d’accéder aux données fortement typées depuis la vue, avec l’aide de l’auto-complétion dans l’IDE.
• @foreach (var p in Model) : itère sur chaque élément de la liste reçue depuis le contrôleur. Le mot-clé Model représente ici la liste transmise par la méthode Index() du contrôleur.
• @p.Nom et @p.Prix : syntaxe Razor pour injecter dynamiquement les valeurs C# dans le code HTML généré.
• <form method="post" asp-action="Ajouter"> : le formulaire envoie les données en HTTP POST à l’action Ajouter du contrôleur. L’attribut asp-action fait partie des tag helpers de Razor, qui facilitent l’écriture d’un HTML lié à la logique C#.

Les bonnes pratiques pour les vues Razor

Retenons qu’il est utile de :

• Utiliser les tag helpers plutôt que les attributs HTML classiques pour générer les balises de formulaire. Ils assurent une meilleure compatibilité avec les conventions d’ASP.NET Core ;
• Ajoutez des validations côté client en combinant les annotations de données dans le modèle et les scripts de validation Razor intégrés (fournis par jQuery Validation) ;
• Protégez vos formulaires avec les tokens CSRF grâce à @Html.AntiForgeryToken(), indispensable dans toute application accessible publiquement ;
• Affichez les messages d’erreur liés au modèle avec asp-validation-for pour chaque champ, et asp-validation-summary pour un affichage global.

Voici une version améliorée du formulaire avec validation et protection CSRF :

@model List<Produit>

<h2>Liste des produits</h2>

<ul>
@foreach (var p in Model)
{
    <li>@p.Nom - @p.Prix €</li>
}
</ul>

<form method="post" asp-action="Ajouter">
    @Html.AntiForgeryToken()

    <div>
        <label asp-for="Nom"></label>
        <input type="text" name="Nom" class="form-control" />
        <span asp-validation-for="Nom"></span>
    </div>

    <div>
        <label asp-for="Prix"></label>
        <input type="number" name="Prix" step="0.01" class="form-control" />
        <span asp-validation-for="Prix"></span>
    </div>

    <button type="submit">Ajouter</button>
</form>

Cette structure améliore l’expérience utilisateur avec des messages d’erreur intégrés, une meilleure accessibilité et une sécurité renforcée. En production, il est également courant d’organiser les vues Razor dans des dossiers selon leur contrôleur parent (par exemple Views/Produits/Index.cshtml).

Ce mini-exemple montre bien la souplesse offerte par Razor : Un rendu rapide côté serveur, fortement typé, et entièrement intégré à la logique métier en C#. Cela rend le développement web avec ASP.NET Core fluide, puissant et maintenable, même pour des applications complexes.

Intégrer les services modernes : Bases de données, api et sécurité

Une application web moderne ne se limite pas à des pages HTML. Elle interagit avec des bases de données, expose des API et protège les données des utilisateurs. ASP.NET Core offre une architecture orientée services avec l’injection de dépendances intégrée.

La connexion à une base de données avec Entity Framework Core

Dans une application web moderne, il est rare que les données se limitent à une simple liste en mémoire. Pour les stocker de manière persistante et les retrouver ultérieurement, il est indispensable de les enregistrer dans une base de données. Avec ASP.NET Core, le moyen le plus pratique et puissant pour gérer l’accès aux données est Entity Framework Core (EF Core), un ORM (Object-Relational Mapper) moderne et open source. EF Core permet de manipuler les données sous forme d’objets C# tout en les enregistrant dans une base relationnelle comme SQL Server, PostgreSQL, MySQL, ou même SQLite, sans avoir à écrire manuellement des requêtes SQL complexes. Cela facilite le développement et réduit le risque d’erreurs.

La création du contexte de base de données

Le contexte de base de données est une classe qui hérite de DbContext et qui fait le lien entre vos entités métier et la base de données. Il contient des DbSet représentant les tables :

public class ApplicationDbContext : DbContext
{
    public DbSet<Produit> Produits { get; set; }

    public ApplicationDbContext(DbContextOptions options) : base(options) { }
}

Dans cet exemple :

• ApplicationDbContext est la classe de contexte.
• DbSet<Produit> Produits correspond à une table Produits dans la base de données.
• Le constructeur reçoit un DbContextOptions qui permet de configurer le type de base de données, la chaîne de connexion, le comportement des migrations, etc.

La configuration dans Program.cs

Ensuite, il faut enregistrer ce contexte dans le conteneur d’injection de dépendances (DI) d’ASP.NET Core. Cela permet au framework d’injecter automatiquement une instance configurée du contexte dans vos contrôleurs ou services :

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

Dans cet exemple, nous utilisons UseSqlServer() pour nous connecter à Microsoft SQL Server. Vous pouvez remplacer cette méthode par UseSqlite(), UseNpgsql() (PostgreSQL) ou UseMySql() (MySQL) selon votre base.

La définition de la chaîne de connexion

La chaîne de connexion doit être définie dans le fichier appsettings.json à la racine du projet :

{
  "ConnectionStrings": {
    "DefaultConnection": "Server=localhost;Database=MaBase;Trusted_Connection=True;MultipleActiveResultSets=true"
  }
}

Cette structure permet de stocker de manière centralisée et sécurisée vos paramètres de connexion. Il est également possible de gérer des chaînes différentes par environnement (ex. appsettings.Development.json et appsettings.Production.json), ce qui est pratique lors du déploiement en production.

L’initialisation de la base avec des migrations

Pour créer la base et appliquer automatiquement la structure correspondant à vos entités, EF Core utilise un système de migrations. Voici les étapes :

dotnet ef migrations add InitialCreate
dotnet ef database update

• migrations add génère une migration basée sur les changements de vos modèles (ajout d’entités, modifications de colonnes, etc.).
• database update applique la migration et met à jour la base de données.

Il est recommandé d’installer l’outil EF Core CLI globalement si ce n’est pas déjà fait :

dotnet tool install --global dotnet-ef

Les bonnes pratiques à retenir

• Séparer les modèles métiers des modèles de base de données pour garder une couche propre (Domain vs Persistence) ;
• Utiliser l’injection de dépendances pour récupérer ApplicationDbContext dans vos contrôleurs et services ;
• Ne jamais stocker de chaînes de connexion sensibles en clair pour la production ; utiliser Azure Key Vault ou des secrets utilisateur.

Une fois ces étapes réalisées, votre application est prête à lire et écrire des données dans une base relationnelle, tout en tirant parti de la puissance d’Entity Framework Core et de ses fonctionnalités avancées comme le suivi des modifications, le LINQ et les migrations automatiques.

La création d’une API REST

Dans le contexte des applications modernes, il est courant d’exposer une API REST pour permettre à d’autres systèmes de consommer les données de votre application. Cela peut inclure des frontends JavaScript (comme React, Angular ou Vue), des applications mobiles (iOS/Android), ou encore des services tiers. ASP.NET Core offre une infrastructure très robuste pour créer des APIs performantes, évolutives et sécurisées. Pour créer une API, il suffit de définir un contrôleur spécifique qui hérite de ControllerBase (au lieu de Controller) et d’utiliser les attributs adaptés pour gérer les routes et les verbes HTTP.

Voici un exemple d’API REST exposant des produits :

[ApiController]
[Route("api/[controller]")]
public class ProduitsApiController : ControllerBase
{
    private readonly ApplicationDbContext _context;

    public ProduitsApiController(ApplicationDbContext context)
    {
        _context = context;
    }

    [HttpGet]
    public async Task<IEnumerable<Produit>> GetProduits()
    {
        return await _context.Produits.ToListAsync();
    }
}

L’analyse du code

• [ApiController] : cet attribut active plusieurs comportements automatiques utiles pour les API, comme la validation automatique du modèle, la gestion des codes de réponse HTTP et la liaison de paramètres à partir du corps de la requête ou de la route.
• [Route("api/[controller]")] : définit le point d’accès de l’API. Le token [controller] sera remplacé par le nom du contrôleur sans le suffixe « Controller » (donc ici, api/produitsapi). Il est courant de renommer ce contrôleur en ProduitsController ou de personnaliser la route (api/produits).
• ControllerBase : classe de base pour les contrôleurs d’API, plus légère que Controller car elle ne supporte pas les vues. Elle expose uniquement les fonctionnalités utiles à la création d’API (retour de JSON, codes HTTP, etc.).
• [HttpGet] : indique que cette méthode répond à une requête HTTP GET. D’autres attributs comme [HttpPost], [HttpPut] ou [HttpDelete] peuvent être utilisés selon les opérations nécessaires.
• async Task<IEnumerable<Produit>> : la méthode est asynchrone, ce qui améliore les performances et l’évolutivité en évitant de bloquer le thread pendant l’accès à la base de données.

Résultat de l’API

Lorsque vous accédez à /api/produitsapi depuis Postman, un navigateur ou un client HTTP, l’API renvoie automatiquement les données sérialisées au format JSON, avec un code de réponse 200 OK :

[
  {
    "id": 1,
    "nom": "Ordinateur portable",
    "prix": 1299.99
  },
  {
    "id": 2,
    "nom": "Clavier mécanique",
    "prix": 89.00
  }
]

Étendre l’API avec d’autres endpoints REST

Une API REST complète doit permettre les opérations CRUD : Create, Read, Update et Delete. Voici un exemple d’extension avec des routes supplémentaires :

[HttpGet("{id}")]
public async Task<ActionResult<Produit>> GetProduit(int id)
{
    var produit = await _context.Produits.FindAsync(id);
    if (produit == null)
        return NotFound();

    return Ok(produit);
}

[HttpPost]
public async Task<ActionResult<Produit>> AjouterProduit(Produit produit)
{
    _context.Produits.Add(produit);
    await _context.SaveChangesAsync();
    return CreatedAtAction(nameof(GetProduit), new { id = produit.Id }, produit);
}

[HttpDelete("{id}")]
public async Task<IActionResult> SupprimerProduit(int id)
{
    var produit = await _context.Produits.FindAsync(id);
    if (produit == null)
        return NotFound();

    _context.Produits.Remove(produit);
    await _context.SaveChangesAsync();
    return NoContent();
}

Les outils utiles pour tester votre API

• Swagger / OpenAPI : ASP.NET Core peut automatiquement générer une documentation interactive de vos endpoints. Ajoutez simplement le package Swashbuckle.AspNetCore ;
• Postman : client HTTP pour tester vos requêtes manuellement ;
• curl ou httpie : outils en ligne de commande pour interagir avec l’API.

Sécurité à considérer

En production, il est important de sécuriser les endpoints API, en particulier ceux qui modifient des données. Voici quelques approches :

• Authentification via JWT (JSON Web Tokens) ;
• Autorisation avec des rôles ou des politiques ;
• Limitation du débit (rate limiting) ;
• Validation du modèle avec [ApiController] + ModelState.IsValid

Grâce à ASP.NET Core, la création d’API REST est fluide et rapide, tout en reposant sur une base solide et extensible. Que ce soit pour exposer des données à un frontend SPA, pour construire un backend d’application mobile, ou pour créer un service destiné à d’autres systèmes, la structure offerte permet une mise en œuvre claire, maintenable et performante.

Configurer l’authentification et l’autorisation

La sécurité est un aspect fondamental de toute application web. ASP.NET Core intègre nativement un système complet pour gérer l’authentification (vérification de l’identité d’un utilisateur) et l’autorisation (gestion de l’accès aux ressources en fonction de cette identité). Le framework offre plusieurs options flexibles et modulaires pour répondre aux besoins de sécurité les plus variés. Voici les principales fonctionnalités disponibles :

• Authentification par cookie avec ASP.NET Core Identity, qui fournit une infrastructure clé en main pour la gestion des utilisateurs, mots de passe, rôles, connexions et jetons.
• Prise en charge des jetons JWT pour les API stateless, avec intégration possible de fournisseurs externes comme Auth0, Azure AD, ou Keycloak.
• Compatibilité avec les protocoles OAuth2 et OpenID Connect pour une authentification fédérée via Google, Microsoft, Facebook, etc.
• Définition de rôles et de politiques d’autorisation personnalisées pour affiner le contrôle d’accès à certains contrôleurs ou actions.
• Protection automatique contre les attaques CSRF (Cross-Site Request Forgery) pour toutes les requêtes POST via les tokens anti-forgery.

Configurer l’authentification avec Identity

Pour activer le système d’authentification de base, vous pouvez intégrer ASP.NET Core Identity, qui repose sur Entity Framework Core pour stocker les utilisateurs et rôles en base de données. Voici un exemple de configuration dans le fichier Program.cs :

builder.Services.AddDefaultIdentity<IdentityUser>()
    .AddEntityFrameworkStores<ApplicationDbContext>();

Cette configuration enregistre les services nécessaires à l’authentification par cookie, en utilisant la table des utilisateurs définie dans la base de données via ApplicationDbContext. Vous pouvez aussi remplacer IdentityUser par une classe personnalisée si vous avez besoin d’ajouter des propriétés spécifiques (nom, prénom, adresse, etc.).

Ajout du middleware dans le pipeline HTTP

Pour que le système d’authentification soit fonctionnel, il est nécessaire d’ajouter les middlewares suivants au pipeline de traitement des requêtes :

app.UseAuthentication();
app.UseAuthorization();

Placez ces lignes après app.UseRouting() et avant la configuration des endpoints dans Program.cs. Le middleware d’authentification s’occupe d’identifier l’utilisateur sur chaque requête, tandis que le middleware d’autorisation vérifie s’il a les droits nécessaires pour accéder à la ressource demandée.

Restreindre l’accès avec l’attribut [Authorize]

Une fois l’authentification en place, vous pouvez facilement restreindre l’accès à certaines routes ou contrôleurs à l’aide de l’attribut [Authorize]. Par exemple :

[Authorize]
public IActionResult TableauDeBord()
{
    return View();
}

Cette action ne sera accessible que pour les utilisateurs authentifiés. Vous pouvez aussi filtrer l’accès selon des rôles :

[Authorize(Roles = "Admin")]
public IActionResult GestionUtilisateurs()
{
    return View();
}

Pour aller plus loin…

ASP.NET Core permet également de définir des politiques d’autorisation personnalisées basées sur des règles complexes, comme des droits par entité, des conditions temporelles, ou des vérifications d’identité externe. Cela se fait via la méthode AddAuthorization dans la configuration des services.