MVC avec ASP.NET Core
Notions théoriques
Qu'est-ce qu'ASP.NET Core ?
ASP.NET Core est le framework web open source de Microsoft, construit sur .NET 8. Il remplace l'ancien ASP.NET Framework (Windows uniquement) et fonctionne sur Windows, Linux et macOS.
Le pattern MVC (Modèle-Vue-Contrôleur) sépare l'application en trois couches :
- Modèle : les données et la logique métier (classes C#, Entity Framework)
- Vue : l'interface utilisateur (fichiers Razor
.cshtml) - Contrôleur : la logique de traitement des requêtes (classes héritant de
Controller)
| Framework | Langage | Vue | ORM |
|---|---|---|---|
| ASP.NET Core MVC | C# | Razor | Entity Framework Core |
| Symfony | PHP | Twig | Doctrine |
| Spring Boot | Java | Thymeleaf | JPA / Hibernate |
Les trois frameworks suivent le même pattern MVC. Si vous connaissez Symfony ou Spring Boot, vous retrouverez les mêmes concepts.
Installer l'environnement
Avant de créer votre premier projet, assurez-vous d'avoir installé :
- SDK .NET 8 : dotnet.microsoft.com
- Visual Studio Community (Windows) ou VS Code avec l'extension C# (toutes plateformes)
- MySQL (version 8+)
Pour vérifier l'installation :
dotnet --version
# Doit afficher 8.x.x
Créer le projet MonBlog
La commande dotnet new mvc génère un projet ASP.NET Core MVC complet :
dotnet new mvc -n MonBlog
cd MonBlog
dotnet run
# Symfony
symfony new MonBlog --full
symfony server:start
# Spring Boot
mvn spring-boot:run
Par défaut, l'application écoute sur http://localhost:5000 (HTTP) et https://localhost:5001 (HTTPS).
Structure du projet
Voici l'arborescence générée :
MonBlog/
├── Controllers/ ← Contrôleurs MVC (HomeController.cs...)
├── Models/ ← Entités et modèles de données
├── Views/ ← Vues Razor (.cshtml)
│ ├── Home/ ← Vues du contrôleur Home
│ ├── Shared/ ← Vues partagées (_Layout.cshtml...)
│ └── _ViewImports.cshtml
├── wwwroot/ ← Fichiers statiques (CSS, JS, images)
├── appsettings.json ← Configuration (connexion BD, logs...)
├── appsettings.Development.json ← Config dev uniquement
├── Program.cs ← Point d'entrée + pipeline HTTP
└── MonBlog.csproj ← Fichier projet (dépendances NuGet)
| ASP.NET Core | Symfony |
|---|---|
Controllers/ | src/Controller/ |
Views/ | templates/ |
Models/ | src/Entity/ |
wwwroot/ | public/ |
appsettings.json | .env |
Program.cs | config/ + public/index.php |
Le fichier Program.cs
Program.cs est le point d'entrée de l'application. Il configure les services et le pipeline HTTP :
var builder = WebApplication.CreateBuilder(args);
// === ZONE SERVICES ===
// Enregistrer les services disponibles dans l'application
builder.Services.AddControllersWithViews();
// Ici on ajoutera : AddDbContext<>, AddIdentity<>, etc.
var app = builder.Build();
// === ZONE PIPELINE HTTP ===
// Définir les middlewares dans l'ordre d'exécution
if (!app.Environment.IsDevelopment())
{
app.UseExceptionHandler("/Home/Error");
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles(); // Servir les fichiers de wwwroot/
app.UseRouting();
app.UseAuthorization();
// Route par défaut : /NomControleur/NomAction/id?
app.MapControllerRoute(
name: "default",
pattern: "{controller=Home}/{action=Index}/{id?}");
app.Run();
Avant app = builder.Build() : on enregistre les services (dépendances injectables).
Après builder.Build() : on configure le pipeline (ordre de traitement des requêtes).
Exemple pratique
Voici le résultat attendu après dotnet run — le fichier Program.cs complet d'un projet MonBlog de départ :
// Program.cs — Point d'entrée de MonBlog
var builder = WebApplication.CreateBuilder(args);
// Activer les contrôleurs MVC avec leurs vues Razor
builder.Services.AddControllersWithViews();
var app = builder.Build();
// Gestion des erreurs selon l'environnement
if (!app.Environment.IsDevelopment())
{
app.UseExceptionHandler("/Home/Error");
app.UseHsts();
}
// Middlewares dans l'ordre
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseAuthorization();
// Route MVC par convention : Controller/Action/id
app.MapControllerRoute(
name: "default",
pattern: "{controller=Home}/{action=Index}/{id?}");
app.Run();
La commande dotnet watch run relance automatiquement l'application à chaque modification de fichier, comme symfony server:start ou le hot-reload de Spring Boot DevTools.
Test de mémorisation/compréhension
TP pour réfléchir et résoudre des problèmes
Dans ce TP, vous allez créer le projet MonBlog et vérifier que tout fonctionne correctement.
Étape 1 — Créer le projet
Ouvrez un terminal et créez le projet MonBlog avec la CLI dotnet.
Donnez à votre projet un nom qui reflète son domaine métier (MonBlog, GestionStock, EcoleApp). Ce nom devient le namespace par défaut de tous vos fichiers C#. Un bon nom évite des refactorisations fastidieuses plus tard.
Étape 2 — Vérifier la structure du projet
Après la création, listez les dossiers principaux et identifiez le rôle de chacun.
Avant d'écrire du code, prenez le temps d'explorer la structure générée. Comprendre le rôle de chaque dossier vous évitera de placer des fichiers au mauvais endroit (par exemple, mettre une image dans Models/ au lieu de wwwroot/images/).
Étape 3 — Lancer l'application et observer Program.cs
Ouvrez Program.cs et complétez la route par défaut.
La route {controller=Home}/{action=Index}/{id?} est la convention MVC : le nom du contrôleur et de l'action correspondent directement aux segments d'URL. C'est identique au routing par convention de Symfony et Spring Boot MVC. Le ? sur {id?} rend ce segment optionnel.