Sommaire
Introduction
L’objectif principal est de vous familiariser avec les concepts fondamentaux des services web (webservice), en mettant particulièrement l’accent sur la mise en pratique de ces connaissances à travers le langage de programmation C#.
Définition et Concepts de Base d’un Service Web
Qu’est-ce qu’un Service Web ?
Un service web est une application ou un composant logiciel accessible sur le réseau, souvent via Internet. Ces services sont conçus pour être interopérables, c’est-à-dire qu’ils peuvent être utilisés par des applications écrites dans des langages différents et déployées sur des environements divers. Ils permettent d’exposer des fonctionnalités ou des données à d’autres applications via des protocoles standardisés.
Principaux Concepts des Services Web
-
Interopérabilité :
- Les services web sont conçus pour être indépendants de la plateforme ou du langage de programmation, ce qui signifie qu’un service web écrit en C# peut être consommé par une application écrite en Java, Python, ou tout autre langage.
-
Communication Basée sur des standards et protocoles ouverts :
- Les services web utilisent les protocoles réseau standard pour la communication, comme HTTP/HTTPS via TCP pour la transmission des messages. Les protocoles et les formats de données sont au format texte dans la mesure du possible, facilitant ainsi la compréhension du fonctionnement global des échanges.
-
Architecture Orientée Services (SOA) :
- Les services web s’intègrent souvent dans une architecture orientée services (SOA), où des composants logiciels distincts communiquent via des services web pour accomplir des tâches spécifiques. Dans une SOA, chaque service est un module autonome qui remplit une fonction spécifique et expose une interface pour interagir avec d’autres services ou applications.
SOAP vs RESTful
Il existe deux principaux styles de services web :
SOAP (Simple Object Access Protocol) est un protocole standardisé qui utilise XML pour le format des messages et inclut des spécifications rigides pour l’échange d’informations structurées. Il est souvent utilisé dans des environnements où la sécurité et la complexité sont critiques.
RESTful (Representational State Transfer) est une architecture plus légère qui utilise les méthodes standard du protocole HTTP (GET, POST, PUT, DELETE) pour effectuer des opérations CRUD (Create, Read, Update, Delete). REST est apprécié pour sa simplicité et son efficacité, particulièrement dans le contexte des API web modernes.
Importance des Services Web
Les services web jouent un rôle essentiel dans le développement logiciel moderne, car ils permettent aux applications de s’intégrer et de collaborer de manière flexible et évolutive. Ils facilitent le développement d’architectures distribuées, la réutilisation des composants logiciels, et la communication entre systèmes disparates, ce qui est crucial dans les environnements de développement complexes d’aujourd’hui.
Dans les grandes structures, chaque service est géré de manière indépendante par une équipe dédiée. Cette approche permet de paralléliser le développement, rendant le processus plus efficace. En assignant à chaque service une responsabilité spécifique, on peut diviser les tâches en plusieurs petits projets autonomes, plutôt que de gérer un seul projet monolithique et complexe.
2 .NET et C#
Présentation de .NET
.NET est une plateforme de développement open-source, conçu et maintenue par Microsoft.
Elle permet de créer une large variété d’applications, notamment des applications web, mobiles, de bureau.
Elle supporte plusieurs langages de programmation, dont C#, F#, et Visual Basic.
.NET offre un environnement de développement unifié multi-plateformes (Windows, Linux, macOS). Les composants principaux de .NET incluent le .NET Runtime pour l’exécution des applications, ASP.NET Core pour le développement d’applications web, et Entity Framework Core pour l’accès aux données. Son architecture modulaire et sa compatibilité avec les services cloud en font un choix populaire pour le développement d’applications modernes et performantes.
Le .NET Runtime
Le .NET Runtime est le moteur d’exécution des applications .NET. Il s’agit d’un environnement qui gère l’exécution du code .NET, assure la gestion de la mémoire et gère les exceptions. Le runtime compile le code intermédiaire (Intermediate Language, ou IL) en code machine natif.
Entity Framework Core
Entity Framework Core est un ORM (Object-Relational Mapper) pour .NET, qui simplifie l’interaction avec les bases de données relationnelles. Il permet aux développeurs de manipuler les données sous forme d’objets C# sans avoir à écrire du SQL. Il supporte une variété de bases de données, telles que SQL Server, SQLite, PostgreSQL, et MySQL.
ASP.NET
ASP.NET est un framework de développement web, conçu par Microsoft, qui permet de créer des applications web modernes, dynamiques et évolutives. Il offre un ensemble complet d’outils et de bibliothèques pour le développement de sites web, d’API RESTful, et d’applications en temps réel. En intégrant des fonctionnalités comme la sécurité, l’authentification, et la gestion des sessions, ASP.NET simplifie le développement de solutions web robustes et performantes, adaptées aux besoins des entreprises modernes.
C#
Le langage en C# constitue le langage le plus connu pour la plateforme .NET. Il est très populaire et se pose en alternative a Java.
C# est un langage à usage général multiplateforme produisant du code hautement performant. C# est un langage orientés objet, il intègre de nombreuses fonctionnalités d’autres paradigmes, notamment la programmation fonctionnelle.
Setup
Installation de .NET
Pour ce cours, nous utilisons .NET 11. La version disponible au 22 octobre 2026 est la Release Candidate 2 (RC 2), une préversion. Installez le SDK 11.0.100-rc.2.26504.105 depuis le site officiel de .NET.
Vérifiez ensuite l’installation avec dotnet --version : la version affichée doit commencer par 11..
IDE
Vous pouvez utiliser l’IDE de votre choix, ou même un éditeur de texte.
Cependant, je vous recommande d’utiliser un des IDE suivant:
Visual Studio 2026 (Community)
Visual Studio est un IDE complet pour développer des applications C#. Pour cibler net11.0 dans l’IDE, utilisez la dernière version de Visual Studio 2026 Insiders compatible avec le SDK .NET 11 RC 2. La version Community suffit pour ce projet.
Rider
Rider est un IDE développé par JetBrains. Vous pouvez l’obtenir gratuitement si vous êtes étudiant.
VS Code
Si vous préférez utiliser un éditeur de texte, je vous recommande d’utiliser VS Code.
Il vous faudra installer les extensions suivantes:
https://marketplace.visualstudio.com/items?itemName=ms-dotnettools.csharp https://marketplace.visualstudio.com/items?itemName=ms-dotnettools.csdevkit https://marketplace.visualstudio.com/items?itemName=ms-dotnettools.vscode-dotnet-pack https://marketplace.visualstudio.com/items?itemName=qwtel.sqlite-viewer
Installation de .NET SDK
Vous pouvez installer le SDK de .NET en utilisant la commande suivante: Ctrl+Shift+P -> .NET: Install net SDK
HTTP
HTTP (HyperText Transfer Protocol) est un protocole de communication client-serveur. Il est utilisé pour transférer des données sur le web. Il est basé sur le modèle requête-réponse. Il utilise le protocole TCP (Transmission Control Protocol) pour établir une connexion entre le client et le serveur.
Protocole
HTTP est un protocole sans état, ce qui signifie que chaque requête est traitée indépendamment des autres. Cela signifie que le serveur ne conserve pas d’informations sur les requêtes précédentes.
Une requête HTTP est composée de plusieurs parties :
- Ligne de requête : contient la méthode, l’URI et la version du protocole.
- En-têtes : contiennent des informations supplémentaires sur la requête.
- Corps : contient les données de la requête.
Une réponse HTTP est également composée de plusieurs parties :
- Ligne de statut : contient la version du protocole, le code de statut et le message de statut.
- En-têtes : contiennent des informations supplémentaires sur la réponse.
- Corps : contient les données de la réponse.
Méthodes HTTP
Il existe plusieurs méthodes HTTP, les plus courantes sont :
- GET : récupère des données à partir du serveur.
- POST : envoie des données au serveur pour traitement.
- PUT : met à jour des données sur le serveur.
- DELETE : supprime des données sur le serveur.
Il existe d’autres méthodes comme HEAD, OPTIONS, PATCH, etc.
Ces méthodes sont des conventions pour indiquer au serveur ce qu’il doit faire avec la requête, mais elles ne sont pas strictement suivies par tous les serveurs.
Codes de statut HTTP
Les codes de statut HTTP sont des codes numériques qui indiquent le résultat de la requête. Les codes de statut sont divisés en cinq catégories :
- 1xx : Informationnel
- 2xx : Succès
- 3xx : Redirection
- 4xx : Erreur du client
- 5xx : Erreur du serveur
Les codes de statut les plus courants sont :
- 200 OK : la requête a réussi.
- 201 Created : la ressource a été créée avec succès.
- 400 Bad Request : la requête est incorrecte.
- 401 Unauthorized : l’accès à la ressource est refusé.
- 404 Not Found : la ressource demandée n’a pas été trouvée.
- 500 Internal Server Error : une erreur interne du serveur s’est produite.
Exemple de requête HTTP GET
Voici un exemple de requête HTTP GET :
GET /index.html HTTP/1.1
Host: www.example.com
User-Agent: Mozilla/5.0
Accept: text/html
Dans cet exemple, le client envoie une requête GET pour récupérer le fichier index.html sur le serveur www.example.com.
User-Agent indique le navigateur utilisé par le client, et Accept indique le type de contenu accepté par le client.
Voici a quoi pourrait ressembler une réponse :
HTTP/1.1 200 OK
Content-Type: text/html
Content-Length: 84
<!DOCTYPE html>
<html>
<head>
</head>
<body>
<h1>Hello, World!</h1>
</body>
</html>
Dans cet exemple, le serveur envoie une réponse avec le code de statut 200 OK et le contenu HTML de la page.
Content-Type indique le type de contenu de la réponse, et Content-Length indique la longueur du contenu en octets.
Exemple de requête HTTP POST
Voici un exemple de requête HTTP POST :
POST /login HTTP/1.1
Host: www.example.com
User-Agent: Mozilla/5.0
Content-Type: application/json
Content-Length: 45
{ "username": "johndoe", "password": "1234" }
Dans cet exemple, le client envoie une requête POST pour se connecter au serveur www.example.com sur la route /login.
Le corps de la requête contient les informations de connexion de l’utilisateur au format JSON.
On précise le type de contenu avec Content-Type et la longueur du contenu avec Content-Length.
Voici a quoi pourrait ressembler une réponse :
HTTP/1.1 200 OK
Content-Type: application/json
Content-Length: 52
{ "message": "Login successful", "token": "abc123" }
Exemple de réponse HTTP avec erreur
Voici un exemple de réponse HTTP avec une erreur :
HTTP/1.1 404 Not Found
Content-Type: text/plain
Content-Length: 13
Page not found
Dans cet exemple, le serveur envoie une réponse avec le code de statut 404 Not Found et le message Page not found.
Conclusion
HTTP est un protocole de communication client-serveur largement utilisé sur le web. Il permet de transférer des données de manière fiable et sécurisée entre les clients et les serveurs. Il est important de comprendre les méthodes HTTP, les codes de statut et les en-têtes pour développer des applications web efficaces et robustes.
Le language C#
Dans cette section, nous allons aborder les concepts de base du langage C#.
Vous y trouverez des exmples de code pour vous aider à comprendre les concepts.
Cette partie n’est pas exhaustive, elle a pour but de vous donner une idée générale du langage C#.
Je vous invite à consulter la documentation officielle pour plus d’informations.
C# Variables
Types
En C# les variables sont typés, voici une liste des types les plus commun
byte b = 255;
short s = -42;
ushort us = 65535;
int i = 1337;
uint ui = 1337;
long l = -13374269;
ulong ul = 13374269;
char c = 'a';
float f = 0.0f;
double d = 0.0d;
bool bo = false;
Tableau
Il est possible de créer des tableau via la syntaxe suivante :
// Crée un tableau de 10 int
int[] tableau = new int[10];
// Assigne 1 à l'index 0
tableau[0] = 1;
// Crée un tableau et l'initialise avec les éléments 0, 2, 4, 6, 8
int[] a = {0, 2, 4, 6, 8};
// Cette ligne équivaut à celle du dessus
int[] b = new int[] {0, 2, 4, 6, 8};
Console.WriteLine(a[1]); // 2
Multi dimensions
On peux également créer des tableaux à plusieurs dimensions.
// Crée un tableau a 2 dimension de 10 * 10
int[,] deuxDimensions = new int[10, 10];
Console.WriteLine(deuxDimensions[0, 0]); // 0
deuxDimensions[0, 0] = 1;
Console.WriteLine(deuxDimensions[0, 0]); // 1
Tableau de tableau
Un tableau multi dimension est différent d’un tableau de tableau. Voici comment créer un tableau de tableau si besoin
int[][] tableauCeption =
{
new int[] {1},
new int[] {1, 1},
new int[] {1, 2, 1},
new int[] {1, 3, 3, 1}
};
Console.WriteLine(tableauCeption[2][1]); // 2
tableauCeption[0][0] = 10;
Console.WriteLine(tableauCeption[0][0]); // 10
Nullables
Il est possible de déclarer une variable nullable en ajoutant ? après le type.
int i = 42;
i = null; // KO
int? nullable = 0;
nullable = null; // OK
Les conditions
Instruction if
int a = 8;
if (a % 2 == 0)
{
Console.WriteLine("Pair");
}
else
{
Console.WriteLine("Impair");
}
Instruction switch-case
int a = 42;
switch (a)
{
case 42:
Console.WriteLine($"21*2");
break;
case 1337:
Console.WriteLine("L33t");
break;
case > 69:
Console.WriteLine("Nice!");
break;
default:
Console.WriteLine($"{a} ne correspond a rien ici");
break;
}
Les boucles
break comme dans les conditions permet d’interrompre une boucle et d’en sortir
Instruction for
for (int i = 0; i < 3; i++)
{
Console.Write(i);
}
Instruction foreach
List<int> listeDeNombre = new() { 0, 1, 1, 2, 3, 5, 8, 13 };
foreach (int nombre in listeDeNombre)
{
Console.Write(nombre);
}
// Typage automatique avec var
foreach (var nombre in listeDeNombre)
{
Console.Write(nombre);
}
Instruction while
int n = 0;
while (n < 5)
{
Console.Write(n);
n++;
}
Instruction do-while
int n = 0;
do
{
Console.Write(n);
n++;
} while (n < 5);
Instruction break
L’instruction break permet de sortir d’une boucle
while (true)
{
Console.WriteLine("Hello");
break; // on sort du while ici
Console.WriteLine("World"); // N'est jamais executé
}
Instruction continue
continue permet de sauter l’itération en cours et de passer a la suivante
for (int i = 0; i < 42; i++)
{
if (i == 2) continue; // si i vaut 2 on s'arrete la et on reprend avec i == 3
Console.Write(i);
}
Structure
Voici un exemple basique d’enumération
enum Saison
{
Printemps,
Ete,
Automne,
Hiver
}
Saison a = Season.Automne;
Console.WriteLine($"La valeur entière de {a} est {(int)a}"); // output: La valeur entière de Autumn est 2
On peut définir manuellement la valeur des membres de l’enum.
enum Saison : uint
{
Printemps = 0,
Ete = 10,
Automne = 20,
Hiver = 30
}
Console
On peut afficher du texte sur le terminal qui a lancé le programme
Console.WriteLine("mon texte");
Console.WriteLine("maVariable vaut : " + maVariable);
// Plus simple, en mettant un $ devant le " on peux insérer les variables entre {}
Console.WriteLine($"maVariable vaut : {maVariable}");
Structure de donnée
En C# il existe plusieurs types de structure de donnée. Les plus courantes sont les classes, les structs, les records et les types anonymes.
Elles ont chacune leur utilité et leur spécificité.
Classes
Les classes sont des types de référence, ce qui signifie que lorsqu’une instance d’une classe est assignée à une nouvelle variable ou passée en argument à une méthode, c’est la référence (adresse mémoire) de l’objet qui est copiée, et non l’objet lui-même. Cela permet de modifier l’objet original via plusieurs références. Les classes sont idéales pour des objets complexes qui nécessitent une gestion de l’héritage, de la polymorphie et de l’encapsulation.
Structs
Les structs sont des types valeur, ce qui signifie qu’une copie complète de la structure est effectuée lorsque vous la passez à une méthode ou l’assignez à une nouvelle variable. Elles sont plus légères que les classes et sont souvent utilisées pour des objets contenant de petites quantités de données immuables, comme les points dans un espace 2D ou des types numériques complexes. L’utilisation des structs peut améliorer les performances dans certaines situations, notamment lorsqu’on veut éviter l’impact des allocations de mémoire sur le tas (heap).
Records
Les records sont des types de référence introduits dans C# 9, conçus pour les objets immuables (par défaut). Ils sont particulièrement utiles pour représenter des objets de données, comme des objets DTO (Data Transfer Objects) ou des objets à usage principalement déclaratif, où la principale fonction de l’objet est de contenir des données. Ils permettent également de bénéficier d’une prise en charge intégrée pour l’égalité structurelle et la comparaison, facilitant leur usage dans des scénarios de traitement de données.
Types Anonymes
Les types anonymes permettent de créer des objets sans définir explicitement une classe ou une structure. Ils sont utiles dans des situations où vous avez besoin de grouper temporairement des données, par exemple dans des requêtes LINQ. Cependant, les types anonymes ne sont généralement utilisés que dans un contexte local, car ils ne peuvent pas être retournés ou passés à travers les frontières d’une méthode de manière pratique.
Collections
En plus de ces types, C# propose des structures de données plus complexes sous forme de collections génériques, telles que List<T>, Dictionary<TKey, TValue>, HashSet<T>, et bien d’autres. Ces collections permettent de stocker et de gérer efficacement des ensembles de données avec différents mécanismes d’accès et de manipulation, tels que l’indexation ou la recherche rapide.
Les classes
C# étant un langage objet, il permet de créer des classes.
Classe
Une classe est un modèle pour créer des objets. Elle peut contenir des champs, des propriétés, des méthodes, des événements, des indexeurs, des opérateurs, des constructeurs et des destructeurs.
public class MaClasse
{
int _valeur;
public MaClasse(int valeur) {
_valeur = valeur
}
}
// Pour l'instancier
MaClasse c = new MaClasse(0);
Constructeur
Une classe peut avoir un ou plusieurs constructeurs. Si aucun constructeur n’est implémenté, un constructeur par défaut (vide) sera automatiquement fourni.
public class MaClasse
{
int _valeur;
public MaClasse(int valeur) {
_valeur = valeur;
}
public MaClasse() {
_valeur = 0;
}
public MaClasse(int valeur) {
_valeur = valeur;
}
// Constructeur pour EF Core
private MaClasse() {}
}
Depuis la version C# 12 il est possible de définir le constructeur directement après le nom de la classe :
public class MaClasse(int valeur)
{
int _valeur = valeur;
}
Destructeur
Il est possible de définir un destructeur pour une classe. Celui-ci est appelé lorsque l’instance de la classe est détruite.
public class MaClasse
{
~MaClasse()
{
Console.WriteLine("Destruction de l'instance");
}
}
Surcharge / Override
Il est possible de surcharger des méthodes. Surcharger une méthode permet de redéfinir son comportement.
Pour surcharger une méthode, il faut qu’elle soit déclarée dans la classe parente avec le mot clé virtual.
Toutes les classes C# héritent de la classe Object qui contient trois méthodes virtuelles principales :
ToString: Permet de retourner une chaine de caractères représentant l’objet.Equals: Permet de comparer deux objets.GetHashCode: Permet de retourner un code de hachage pour l’objet.
toString
Lorsque vous affichez une instance d’une classe dans la console, elle vous renvoie par défaut le nom complet de la classe : Namespace.Classe.
Voici a quoi ressemble la méthode ToString de la classe Object.
public virtual string? ToString() => this.GetType().ToString();
Vous pouvez surcharger la méthode toString pour choisir quoi afficher.
public class User
{
public int Id { get; set; }
public string? Name { get; set;}
public string? Email { get; set;}
public string? PasswordHash { get; set; }
// Notez la présence de override qui précise que cette méthode existe deja et que l'on la surcharge
public override string ToString()
{
return $"Id: ${Id} Name: ${Name} Email : ${Email} Pass: ${PasswordHash}";
}
}
User u = new User():
u.Id = 0;
u.Name = "abc";
u.Email = "a@b.c";
u.PasswordHash = "";
Console.WriteLine(u);
// Affichera
// Id: 0 Name: abc Email : a@b.c Pass:
C’est très pratique pour déboguer le contenu d’une classe.
Constructeur primaire
Depuis la version 12 de C#, il est possible de définir un constructeur primaire.
Ce constructeur permet de définir les propriétés de la classe directement dans la déclaration de celle-ci.
public class User(int id, string name, string email, string passwordHash)
{
public int Id { get; set; } = id;
public string Name { get; set; } = name;
public string Email { get; set; } = email;
public string PasswordHash { get; set; } = passwordHash;
}
Vous pouvez également combiner un constructeur primaire avec un constructeur classique.
Lorsque vous utilisez un constructeur primaire, vous pouvez l’appeler dans un autre constructeur en utilisant le mot clé this pour appeler le constructeur primaire.
public class User(int id, string name, string email, string passwordHash)
{
public int Id { get; set; } = id;
public string Name { get; set; } = name;
public string Email { get; set; } = email;
public string PasswordHash { get; set; } = passwordHash;
public User(string name, string email, string passwordHash): this(0, name, email, passwordHash) {}
}
Struct
Une structure est un type de données qui permet de regrouper des données de types différents. Elle est similaire à une classe, mais avec quelques différences.
La principale différence entre une structure et une classe est que les structures sont des types de valeur et les classes sont des types de référence.
Cela implique que quand on envoie une structure en paramètre à une méthode, une copie de la structure est envoyée. Alors que pour une classe, c’est une référence qui est envoyée.
Un struct est déclaré avec le mot clé struct.
public struct Personne
{
public string Nom;
public int Age;
}
Il est possible de définir un constructeur pour une structure comme pour une classe.
public struct Personne
{
public string Nom;
public int Age;
public Personne(string nom, int age)
{
Nom = nom;
Age = age;
}
}
Il est possible de définir des méthodes dans une structure.
public struct Personne
{
public string Nom;
public int Age;
public Personne(string nom, int age)
{
Nom = nom;
Age = age;
}
public void Afficher()
{
Console.WriteLine($"Nom: {Nom}, Age: {Age}");
}
}
Record
Les records sont des classes immuables qui permettent de définir des objets de données.
Déclaration
Un record est déclaré avec le mot clé record.
public record Personne(string Nom, int Age);
Personne p = new Personne("Jean", 25);
ou comme ceci, même si on préfère la première méthode
public record Personne
{
public string Nom { get; init; }
public int Age { get; init; }
}
vous pouvez ajouter des méthodes dans un record.
Personne(string Nom, int Age)
{
public void Afficher()
{
Console.WriteLine($"Nom: {Nom}, Age: {Age}");
}
}
Anonymous
Les types anonymes permettent de créer des objets sans définir de classe. Ils sont utiles pour les retours de méthodes ou pour les objets temporaires.
var personne = new { Nom = "Alice", Age = 25 };
Console.WriteLine(personne.Nom); // Alice
Collections
En plus de ces types, C# propose des structures de données plus complexes sous forme de collections génériques, telles que List<T>, Dictionary<TKey, TValue>, HashSet<T>, et bien d’autres.
Ces collections permettent de stocker et de gérer efficacement des ensembles de données avec différents mécanismes d’accès et de manipulation, tels que l’indexation ou la recherche rapide.
Voici quelques-unes des collections les plus couramment utilisées en C# :
List<T>
La classe List<T> est une collection générique qui permet de stocker une liste d’éléments de type T. Elle fournit des méthodes pour ajouter, supprimer, rechercher et trier des éléments, ainsi que pour effectuer d’autres opérations courantes sur les listes.
List<int> nombres = new List<int>();
nombres.Add(1);
nombres.Remove(1);
var number = nombres.Find(x => x == 1);
nombres.Sort((a,b) => a.CompareTo(b));
nombres.Reverse();
foreach (var num in nombres)
{
Console.WriteLine(num);
}
Dictionary<TKey, TValue>
La classe Dictionary<TKey, TValue> est une collection générique qui permet de stocker des paires clé-valeur. Chaque élément du dictionnaire est une paire clé-valeur, où la clé est unique et est utilisée pour accéder à la valeur associée.
Dictionary<string, int> ages = new Dictionary<string, int>();
ages.Add("Alice", 25);
ages["Bob"] = 30;
ages.Remove("Alice");
foreach (var kvp in ages)
{
Console.WriteLine($"{kvp.Key}: {kvp.Value}");
}
HashSet<T>
La classe HashSet<T> est une collection générique qui permet de stocker un ensemble d’éléments uniques. Elle fournit des méthodes pour ajouter, supprimer et tester la présence d’éléments dans l’ensemble.
HashSet<int> nombres = new HashSet<int>();
nombres.Add(1);
nombres.Add(2);
nombres.Remove(1);
bool contains = nombres.Contains(2);
foreach (var num in nombres)
{
Console.WriteLine(num);
}
Queue<T>
La classe Queue<T> est une collection générique qui implémente une file d’attente (FIFO - First In First Out). Elle fournit des méthodes pour ajouter des éléments à la fin de la file, supprimer des éléments du début de la file, et accéder à l’élément en tête de file.
Queue<string> files = new Queue<string>();
files.Enqueue("Document1.txt");
files.Enqueue("Document2.txt");
string firstFile = files.Dequeue();
string nextFile = files.Peek();
Stack<T>
La classe Stack<T> est une collection générique qui implémente une pile (LIFO - Last In First Out). Elle fournit des méthodes pour ajouter des éléments au sommet de la pile, supprimer des éléments du sommet de la pile, et accéder à l’élément au sommet de la pile.
Stack<string> pile = new Stack<string>();
pile.Push("Document1.txt");
pile.Push("Document2.txt");
string topFile = pile.Pop();
string nextFile = pile.Peek();
Propriété
Les propriétés (properties en anglais) permettent d’encapsuler les champs d’une classe. Elles permettent de contrôler l’accès aux champs et de les protéger.
Sans propriété, il est possible de modifier directement les champs d’une classe. Cela peut être dangereux car il est possible de modifier un champ sans vérifier les valeurs.
Voila un exemple de classe sans propriété:
public class Personne
{
public string Nom;
public int Age;
}
Il est possible de modifier directement les champs Nom et Age sans vérifier les valeurs.
Personne p = new Personne();
p.Nom = "Jean";
p.Age = -5;
Pour éviter cela, il est possible d’utiliser des propriétés.
public class Personne
{
private string _nom;
private int _age;
public string Nom
{
get { return _nom; }
set { _nom = value; }
}
public int Age
{
get { return _age; }
set { _age = value; }
}
}
Il est maintenant impossible de modifier directement les champs Nom et Age. Il est nécessaire de passer par les propriétés.
Personne p = new Personne();
p.Nom = "Jean"; // OK
p.Age = -5; // OK
Il est possible de modifier les propriétés pour ajouter des vérifications.
public class Personne
{
private string _nom;
private int _age;
public string Nom
{
get { return _nom; }
set
{
if (value.Length > 0)
{
_nom = value;
}
}
}
public int Age
{
get { return _age; }
set
{
if (value > 0)
{
_age = value;
}
}
}
}
Il est maintenant impossible de modifier le nom avec une chaine vide ou l’age avec une valeur négative.
Personne p = new Personne();
p.Nom = ""; // KO
p.Age = -5; // KO
Il est possible de mettre les getter et setter en private
public class Personne
{
public string Nom { get; private set; }
public int Age { private get; set; }
}
Il est maintenant impossible de modifier le nom en dehors de la classe. Il est également impossible de lire l’age en dehors de la classe.
Personne p = new Personne();
p.Nom = "Jean"; // KO
Console.WriteLine(p.Age); // KO
Il existe également une variante pour le set qui est init
Dans ce cas, il est possible de modifier la valeur uniquement dans le constructeur.
public class Personne
{
public string Nom { get; init; }
public int Age { get; init; }
}
Il est maintenant impossible de modifier le nom et l’age en dehors du constructeur.
Personne p = new Personne { Nom = "Jean", Age = 25 }; // OK
p.Nom = "Jean"; // KO
p.Age = 25; // KO
Méthode
Une méthode est un bloc de code qui effectue une tâche spécifique. En C#, les méthodes sont définies dans des classes et peuvent être appelées pour exécuter leur code.
Une fonction dans une classe == méthode.
Déclaration
Comme une fonction C#, une méthode est déclarée avec un type de retour, un nom et une liste d’arguments.
public int Addition(int a, int b)
{
return a + b;
}
A la différence des fonctions C#, les méthodes peuvent accéder à l’instance de la classe via le mot clé this.
Elles peuvent également accéder à des champs et des propriétés de la classe.
public class Calculatrice
{
private int _resultat;
private int osef;
public void Addition(int a)
{
_resultat += a;
}
public void Soustraction(int a)
{
_resultat -= a;
}
public int Resultat()
{
return ._resultat;
}
private Calculatrice(int resultat, int osef)
{
_resultat = resultat;
// Comme `osef` est un champ de la classe et un argument de la méthode, il faut utiliser `this` pour accéder au champ de la classe.
// Car par défaut, `osef` fait référence à l'argument de la méthode qui est prioritaire.
this.osef = osef;
}
}
Visibilité
La visibilité d’une classe, d’une méthode ou d’une propriété permet de définir si un élément est accessible depuis l’extérieur de la classe. Il existe plusieurs niveaux de visibilité en C#.
Niveaux de visibilité
public: accessible depuis n’importe où.private: accessible uniquement depuis la classe.protected: accessible depuis la classe et les classes dérivées.
Exemple
public class Personne
{
private string _nom;
private int _age;
public string Nom
{
get { return _nom; }
set
{
if (value.Length > 0)
{
_nom = value;
}
}
}
public int Age
{
get { return _age; }
set
{
if (value > 0)
{
_age = value;
}
}
}
protected void Afficher()
{
Console.WriteLine($"Nom: {Nom}, Age: {Age}");
}
}
Main
Tout programme qui se lance a besoin d’un point d’entrée.
Par défaut le point d’entrée en C# est la fonction Main.
Cette fonction doit être déclaré dans une classe et une seule
class Programme
{
static void Main(string[] args)
{
// Le programme commence ici
Console.WriteLine("Hello, World!");
}
}
Sauf pour les consoles
Si votre projet est un projet console, vous pouvez ne pas utiliser Main.
Vous pouvez écrire votre code directement dans le fichier Program.cs et le compilateur s’occupera de créer le Main pour vous
L’exemple précédent s’écrirai donc simplement comme ceci.
Console.WriteLine("Hello, World!");
Structure
Un programme C# se compose d’un ou plusieurs fichiers, chacun de ces fichier peux contenir :
- Un ou plusieurs namespace
- Une ou plusieurs classe/struct/enum
- Une lise d’import (
using)
Voici un exemple basique
using System; // Importe les définitions du namespace System
namespace MonNamespace;
class MaClasse
{
}
class Programme
{
static void Main(string[] args)
{
// Le programme commence ici
Console.WriteLine("Hello, World!");
}
}
Lambda
Une lambda est une fonction anonyme. Les lambdas sont souvent utilisées pour définir des expressions de fonction qui sont passées comme arguments à des méthodes. Les lambdas peuvent capturer des variables locales et des paramètres de méthode.
Func<int, int> square = x => x * x;
Console.WriteLine(square(5)); // 25
Func<int, int, bool> testForEquality = (x, y) => x == y;
Console.WriteLine(testForEquality(5, 5)); // True
Action<string> greet = name =>
{
string greeting = $"Hello {name}!";
Console.WriteLine(greeting);
};
greet("World"); // Hello World!
LINQ
LINQ est un acronyme pour Language Integrated Query. Il s’agit d’une extension du langage C# qui permet de manipuler des données de manière plus simple et plus lisible. LINQ permet de requêter des données de différentes sources (tableaux, listes, bases de données, etc.) en utilisant une syntaxe similaire à SQL.
Syntaxe
La syntaxe de base de LINQ est la suivante :
Prenons uen classe Confiture avec un champ Name et Year :
public class Confiture
{
public string Name { get; set; }
public int Year { get; set; }
}
Insérons quelques données dans une liste :
List<Confiture> confitures = new List<Confiture>
{
new Confiture { Name = "Fraise", Year = 2020 },
new Confiture { Name = "Fraise", Year = 2021 },
new Confiture { Name = "Abricot", Year = 2021 },
new Confiture { Name = "Mûre", Year = 2023 },
new Confiture { Name = "Framboise", Year = 2021 },
new Confiture { Name = "Framboise", Year = 2024 }
};
Si l’on souhaite récupérer les confitures de fraise :
List<Confiture> confitureDeFraises = confitures
.Where(c => c.Name == "Fraise")
.ToList();
Si l’on souhaite récupérer les confitures de fraise de 2021 :
List<Confiture> confitureDeFraises2021 = confitures
.Where(c => c.Name == "Fraise" && c.Year == 2021)
.ToList();
// ou en moins optimisé
List<Confiture> confitureDeFraises2021 = confitures
.Where(c => c.Name == "Fraise")
.Where(c => c.Year == 2021)
.ToList();
Si l’on souhaite récupérer les confitures triées par année :
List<Confiture> confituresTriees = confitures
.OrderBy(c => c.Year)
.ToList();
On utilise Select pour sélectionner une propriété spécifique :
// Récupérer les noms des confitures
List<string> nomsConfitures = confitures
.Select(c => c.Name)
.ToList();
On peut combiner les méthodes :
// Récupérer les noms des confitures de fraise triées par année
string[] nomsConfituresFraise = confitures
.Where(c => c.Name == "Fraise")
.OrderBy(c => c.Year)
.Select(c => c.Name)
.ToArray();
async et await en C#
Introduction
En C#, la programmation asynchrone permet d’effectuer des opérations de longue durée, comme les appels réseau ou l’accès à des base de données, sans bloquer le thread principal. Cela améliore la réactivité des applications en leur permettant de continuer à répondre aux interactions pendant l’exécution de ces tâches.
Le langage C# fournit deux mots-clés importants pour gérer les opérations asynchrones : async et await.
Le Mot-Clé async
Le mot-clé async est utilisé pour marquer une méthode comme asynchrone. Cela signifie que la méthode peut contenir des opérations asynchrones qui ne bloqueront pas le thread sur lequel elles s’exécutent. Une méthode marquée async doit retourner un type Task, Task<T>, ou void.
Exemple d’une Méthode async
public async Task<string> FetchDataAsync()
{
// Simulation d'un appel réseau asynchrone
await Task.Delay(2000); // Simule une attente de 2 secondes
return "Données récupérées";
}
Dans cet exemple, FetchDataAsync est une méthode asynchrone qui retourne un Task<string>. La méthode utilise await pour attendre la fin de Task.Delay(2000), qui simule un délai de 2 secondes.
Le Mot-Clé await
Le mot-clé await est utilisé pour indiquer qu’une méthode asynchrone doit attendre la fin d’une opération asynchrone avant de continuer. Lorsqu’une opération asynchrone est “awaitée”, le contrôle est temporairement retourné au thread appelant, ce qui permet à l’application de rester réactive.
Exemple d’utilisation de await
Copier le code
public async Task ProcessDataAsync()
{
string data = await FetchDataAsync(); // Attend la fin de FetchDataAsync
Console.WriteLine(data); // Affiche "Données récupérées"
}
Dans cet exemple, ProcessDataAsync appelle la méthode FetchDataAsync et utilise await pour attendre son résultat. Pendant que FetchDataAsync est en cours d’exécution, ProcessDataAsync ne bloque pas le thread principal et attendra que la tâche soit terminée pour afficher les données.
Pourquoi Utiliser async et await ?
L’utilisation de async et await permet de simplifier le code asynchrone. Plutôt que de gérer manuellement des callbacks ou des threads, vous pouvez écrire du code asynchrone qui ressemble à du code synchrone classique. Cela rend le code plus lisible, plus facile à écrire, et réduit les risques d’erreurs.
Les exceptions
Les exceptions sont des erreurs qui surviennent lors de l’exécution d’un programme.
Quand on ne souhaite pas traiter une exception, on peut la laisser remonter jusqu’à la méthode appelante.
On utilise pour ca le mot clé throw.
Instruction throw
Pour lancer une exception on utilise le mot clé throw de cette manière.
throw new Exception("Erreur");
On notera l’utilisation de la classe Exception qui prend en paramètre un message d’erreur.
Instruction try-catch
Pour empecher une exception de remonter jusqu’à la méthode appelante, on utilise le bloc try-catch.
De cette manière on peut traiter l’exception et éviter que le programme ne s’arrête.
try
{
throw new Exception("Erreur");
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
Différents types d’exceptions
Il existe plusieurs types d’exceptions.
Chaque type d’exception hérite de la classe Exception.
On peux créer nos propres exceptions en héritant de la classe Exception.
class MaPropreException : Exception
{
public MaPropreException(string message) : base(message) { }
}
Traiter plusieurs exceptions
On peut les traiter de manière spécifique.
Ici on traite l’exception MaPropreException avant l’exception générique Exception.
Si l’exception envoyé par codeQuiPeutLancerUneException est de type MaPropreException alors le premier bloc catch sera exécuté.
Sinon le deuxième bloc catch sera exécuté.
try
{
codeQuiPeutLancerUneException();
}
catch (MaPropreException e)
{
Console.WriteLine($"Erreur spécifique : ${e.Message}");
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
Qu’est-ce que le JSON ?
JSON (JavaScript Object Notation) est un format léger de structuration des données. Il est largement utilisé pour échanger des données entre un serveur et un client, ou entre différentes couches d’une application. Le JSON est facile à lire et à écrire pour les humains, et simple à analyser et à générer pour les machines.
Exemple de JSON
{
"nom": "Alice",
"âge": 25,
"compétences": ["C#", "ASP.NET", "Blazor"],
"estActif": true
}
Dans cet exemple, les données décrivent une personne avec un nom, un âge, une liste de compétences, et un statut d’activité.
Qu’est-ce que la Sérialisation ?
La sérialisation est le processus de conversion d’un objet en une représentation textuelle ou binaire qui peut être facilement stockée ou transmise. En C#, la sérialisation en JSON permet de convertir un objet C# en une chaîne JSON. À l’inverse, la désérialisation est le processus de conversion d’une chaîne JSON en un objet C#.
C# vers JSON
Pour sérialiser un objet en JSON en C#, vous pouvez utiliser la classe JsonSerializer fournie par le namespace System.Text.Json.
using System;
using System.Text.Json;
public class Personne
{
public string Nom { get; set; }
public int Âge { get; set; }
public string[] Compétences { get; set; }
public bool EstActif { get; set; }
}
public class Exemple
{
public static void Main()
{
var personne = new Personne
{
Nom = "Alice",
Âge = 25,
Compétences = new[] { "C#", "ASP.NET", "Blazor" },
EstActif = true
};
string jsonString = JsonSerializer.Serialize(personne);
Console.WriteLine(jsonString);
}
}
Résultat:
{"Nom":"Alice","Âge":25,"Compétences":["C#","ASP.NET","Blazor"],"EstActif":true}
JSON vers C#
La désérialisation est le processus inverse de la sérialisation. Elle convertit une chaîne JSON en un objet C#. Cela est particulièrement utile pour recevoir des données JSON d’une API et les convertir en objets manipulables dans votre code.
using System;
using System.Text.Json;
public class Personne
{
public string Nom { get; set; }
public int Âge { get; set; }
public string[] Compétences { get; set; }
public bool EstActif { get; set; }
}
public class Exemple
{
public static void Main()
{
string jsonString = "{\"Nom\":\"Alice\",\"Âge\":25,\"Compétences\":[\"C#\",\"ASP.NET\",\"Blazor\"],\"EstActif\":true}";
// TODO read from file
Personne personne = JsonSerializer.Deserialize<Personne>(jsonString);
Console.WriteLine($"Nom: {personne.Nom}, Âge: {personne.Âge}, Est Actif: {personne.EstActif}");
}
}
Résultat:
Nom: Alice, Âge: 25, Est Actif: True
Requête HTTP
Pour faire communiquer nos services, on utilise des requêtes HTTP.
Emmetre des requêtes HTTP
Voici quelques exemples de requêtes.
using System.Net.Http.Json;
HttpClient client = new HttpClient();
client.BaseAddress = new Uri("http://localhost:5000/");
var todo = new { Text = "text", Status = false };
int UserId = 10;
// Requete GET sans paramètre
HttpResponseMessage listResponse = await client.GetAsync("api/Todo/list/");
// Requete GET avec paramètre
HttpResponseMessage userListResponse = await client.GetAsync($"api/Todo/list/{UserId}");
// Requete POST avec donnée
HttpResponseMessage createResponse = await client.PostAsJsonAsync("api/Todo/create/", todo);
// Requete POST avec paramètre et donnée
HttpResponseMessage userCreateResponse = await client.PostAsJsonAsync($"api/Todo/create/{UserId}", todo);
// Requete POST avec paramètre et sans donnée
HttpResponseMessage emptyPostResponse = await client.PostAsync($"api/Todo/create/{UserId}", null);
// Autre méthode (PUT et DELETE)
HttpResponseMessage putResponse = await client.PutAsJsonAsync("api/Todo/update/", todo);
HttpResponseMessage deleteResponse = await client.DeleteAsync("api/Todo/delete/");
Utiliser la réponse
On sait comment envoyer une requêtes, maintenant récupéront sont résultat.
// On emet notre requete
HttpResponseMessage response = await client.PostAsJsonAsync("api/User/Login", new
{
Username = "Alice",
Password = "Secret123!"
});
response.EnsureSuccessStatusCode();
// On recupere le résultat et on le transforme en une instance de LoginResponse
LoginResponse? login = await response.Content.ReadFromJsonAsync<LoginResponse>();
// Si l'on veux récuperer le texte renvoyé et ne pas le convertir en instance d'une classe on le fait de la manière suivante
string str = await response.Content.ReadAsStringAsync();
// La route Login renvoie un token et un utilisateur public.
public class LoginResponse
{
public required string Token { get; set; }
public required UserPublic User { get; set; }
}
Gestion des erreurs
Pour gérer les erreurs, on peut utiliser les exceptions.
try
{
HttpResponseMessage response = await client.PostAsJsonAsync("api/User/Login", new
{
Username = "Alice",
Password = "Secret123!"
});
response.EnsureSuccessStatusCode(); // Lève une exception si le code de retour n'est pas entre 200-299
}
catch (HttpRequestException e)
{
Console.WriteLine($"Message : {e.Message}");
}
Headers
Pour ajouter des headers à une requête, on utilise la propriété DefaultRequestHeaders de HttpClient.
Par exemple pour ajouter un token JWT à une requête :
if (login is not null)
{
client.DefaultRequestHeaders.Authorization =
new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", login.Token);
}
ASP.NET
Création d’un projet API
Pour créer un projet Web API, vous pouvez utiliser la commande suivante :
dotnet new webapi --framework net11.0 --use-controllers --no-https -n NomDuProjet
On ajoute les options
--framework net11.0 pour cibler .NET 11.
--no-https pour ne pas utiliser HTTPS
Par défaut, Program.cs utilise des instructions de premier niveau. L’option facultative --use-program-main génère une classe Program avec une méthode Main explicite ; les exemples de démarrage du cours se placent alors dans cette méthode.
-n NomDuProjet permet de donner un nom à notre projet, vous pouvez le changer si vous le souhaitez.
--use-controllers pour utiliser les controllers au lieu des API minimales.
Structure d’un projet Web API
Pour créer un projet Web API, il faut d’abord créer un projet ASP.NET Core 11. Pour cela, on peut utiliser la commande suivante :
dotnet new webapi --framework net11.0 --use-controllers --no-https --name ConfitureApi
Cette commande va créer un projet Web API nommé ConfitureApi avec les options suivantes :
--framework net11.0: Cible .NET 11.--use-controllers: Crée un contrôleur par défaut.--no-https: Désactive le support HTTPS.--name ConfitureApi: Donne le nomConfitureApiau projet.
Structure du projet
Voici la structure de fichiers et de dossiers générée par la commande précédente :
ConfitureApi/
├── Controllers/
│ └── WeatherForecastController.cs
├── Properties/
│ └── launchSettings.json
├── appsettings.json
├── ConfitureApi.csproj
├── Program.cs
└── WeatherForecast.cs
Controllers/: Dossier contenant les contrôleurs de l’API. C’est ici que l’on définit les routes et les actions.Controllers/WeatherForecastController.cs: Contrôleur par défaut généré par la commande.Properties/: Dossier contenant les fichiers de configuration.appsettings.json: Fichier de configuration de l’application.ConfitureApi.csproj: Fichier de configuration du projet.Program.cs: Contient les instructions de premier niveau qui configurent et démarrent l’application. L’option facultative--use-program-mainpermet de les placer dans une méthodeMainexplicite.WeatherForecast.cs: Modèle de données pour les prévisions météo.
On utilise généralement :
- le dossier
Controllerspour stocker les contrôleurs de l’API - le dossier
Models(pas crée automatiquement)pour les modèles de données, - le dossier
Servicespour les services utilisés par l’API. - le dossier
Migrationspour les migrations de base de données.
Contrôleur par défaut
Le contrôleur WeatherForecastController généré par défaut contient une action Get qui renvoie des prévisions météo aléatoires.
Controlleur
Un controlleur est une classe qui hérite de ControllerBase.
Cette classe est précédé par 2 annotations
// Indique que notre controller sera accessible par l'url api/LeNomDuController
[Route("api/[controller]")]
// Indique que cette classe est un controleur d'API
[ApiController]
Annotations
Dans notre classe on défini des méthodes qui seront accessible depuis une route HTTP.
Cela se fait simplement en ajoutant une annotation avant la méthode. Voici différents exemples d’annotations possible.
// Annotation basique, écoute sur la même URL que le controlleur
// filtre selon la méthode de la requtête HTTP GET/POST/PUT/DELETE
[HttpGet]
[HttpPost]
[HttpPut]
[HttpDelete]
// On peux surcharger l'URL a laquel la méthode sera appelé
// Ici pour appeler cette méthode on contactera /api/Controller/a/b/c
[HttpGet("a/b/c")]
// On peux également récuperer des paramètre passé dans l'url
// Ici on déclare que dans notre url on a un paramètre id
// On retrouve ce paramètre dans les arguments de notre méthode
[HttpGet("a/{id}")]
public void Param(int id) {}
Envoyer de la donnée
Dans l’exemple précédent on a vu que l’on pouvait passer des paramètres dans l’URL. Cela est cependant peux adapter quand notre volume de donnée a transmettre est important.
Dans ce cas la on utilise en général les méthode POST ou PUT qui servent a transmettre plus d’informations.
[HttpPost]
public void POST(Data data)
{
Console.WriteLine(data.ChampLong);
}
// On peux même combiner les 2 en passant par url et par donnée
[HttpPost("{id}")]
public void POST(int id, Data data)
{
Console.WriteLine(id);
Console.WriteLine(data.ChampLong);
}
public class Data
{
public string ChampLong { get; set; }
public int[] TableauDeInt { get; set; }
}
Exemple
Dans l’exemple qui suit on définit un controller Random qui sera joignable sur /api/Random.
Il expose 3 méthode qui sont appelable sur les URLs suivante :
- GET /api/Random
- GET /api/Random/0/100 0 = min 100 = max
- POST /api/Random data={ “min”: 0, “max”: 100 }
using Microsoft.AspNetCore.Mvc;
namespace MonApp.Controllers
{
[Route("api/[controller]")]
[ApiController]
public class RandomController : ControllerBase
{
// GET: api/Random
[HttpGet]
public int RandomGet()
{
return System.Random.Shared.Next();
}
// GET api/Random/0/100
[HttpGet("{min}/{max}")]
public int RandomGetMinMax(int min, int max)
{
return System.Random.Shared.Next(min, max);
}
// POST api/Random/post DATA JSON { "min": 0, "max": 100 }
[HttpPost]
public int RandomPost(RandomValue value)
{
return System.Random.Shared.Next(value.Min, value.Max);
}
}
public class RandomValue
{
public int Min { get; set; }
public int Max { get; set; }
}
}
Code de retour
Code de retour
Une réponse HTTP contient un code de retour. Ce code permet de savoir si la requête a été traité correctement ou non.
Vous connaissez très probablement le 404 - Not Found.
IActionResult
En ASP.Net le type de retour s’exprime avec une classe ActionResult qui implémente l’interface IActionResult.
Il en existe plusieurs qui hérite de ActionResult.
En voici quelques unes :
return Ok(value); // 200 - OK tout s'est bien passé, on renvoi la valeur a l'appelant
return CreatedAtAction(nameof(Getter), new { id = value.Id }, value); // 201 - Le résultat a bien été crée
return NoContent(); // 204, sans corps de réponse
return BadRequest("C'est pas valide"); // 400
return NotFound("Erreur: j'ai pas trouvé"); // 404
return StatusCode(500, "Erreur interne"); // 500
La dernière méthode StatusCode permet de renvoyer un code HTTP personnalisé.
Exemple d’usage
Une méthode qui renvoi un objet Confiture si elle existe dans la base de donnée.
On peux voir que le type de retour est ActionResult<Confiture> ce qui signifie que l’on renvoi un objet de type Confiture avec un code 200 ou un code d’erreur.
Ici on renvoi un code 404 si la confiture n’existe pas dans la base.
[HttpGet("{id}")]
public async Task<ActionResult<Confiture>> GetConfiture(int id)
{
var confiture = await _context.Confitures.FindAsync(id);
if (confiture == null)
{
return NotFound(); // 404
}
return Ok(confiture); // 200
}
Par défaut le code de retour est 200 - OK si on ne spécifie pas de code de retour.
Les deux lignes suivantes sont équivalentes.
return Ok(confiture);
return confiture;
Scalar
Scalar fournit une interface web pour tester notre service.
On l’active en installant un paquet NuGet.
Pour cela, lancez cette commande dans le dossier de votre projet (celui qui contient le fichier .csproj) :
dotnet add package Scalar.AspNetCore
Dans Program.cs, conservez les instructions de premier niveau utilisées par défaut et ajoutez la configuration Scalar. L’exemple complet ci-dessous enregistre OpenAPI et les contrôleurs, puis affiche Scalar en développement :
using Scalar.AspNetCore;
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllers();
builder.Services.AddOpenApi();
var app = builder.Build();
if (app.Environment.IsDevelopment())
{
app.MapOpenApi();
app.MapScalarApiReference();
}
app.MapControllers();
app.Run();
Si vous avez choisi --use-program-main lors de la création du projet, placez les instructions de démarrage ci-dessus dans la méthode Main existante et gardez using Scalar.AspNetCore; en haut du fichier.
Pour lancer automatiquement scalar on modifie le fichier Properties/launchSettings.json.
On passera launchBrowser à true et launchUrl à scalar/v1 :
{
"$schema": "https://json.schemastore.org/launchsettings.json",
"profiles": {
"http": {
"commandName": "Project",
"dotnetRunMessages": true,
"launchBrowser": true,
"applicationUrl": "http://localhost:5000",
"launchUrl": "scalar/v1",
"environmentVariables": {
"ASPNETCORE_ENVIRONMENT": "Development"
}
}
}
}
Conservez les autres réglages utiles de votre profil existant. Le port 5000 correspond à celui de la semaine 1 ; adaptez-le si vous en avez choisi un autre. L’environnement Development permet d’activer le bloc qui expose OpenAPI et Scalar.
Injection de dépendance
Comme on utilise le framework ASP.Net on ne contrôle pas l’instanciation de nos Controller.
Si j’ai besoin d’avoir accès a un Client HTTP ou a une classe particulière dans mon controller, j’utilise l’injection de dépendance.
Dans mon Program.cs je peux demander de au framework de créer certaine classe pour moi.
// Permet au framework d'injecter une instance de MaClasse dans les controller
// Scoped signifie qu'a chaque requête l'instance est recrée
builder.Services.AddScoped<MaClasse>();
// Si je veux avoir un instance persistante je peux demander un singleton
builder.Services.AddSingleton<MaClasse>();
// Si je veux avoir accès un HTTPClient on peux utiliser la focntion suivante
builder.Services.AddHttpClient();
namespace Exemple.Controllers
{
[Route("api/[controller]")]
[ApiController]
public class ExempleController : ControllerBase
{
HttpClient _client;
MaClasse _maClasse;
// Dans mon constructeur je demande un HTTPClient et une instance de MaClasse
// Ceux si seront automatiquement crée par le framework sans action de notre part autre que l'ajout dans le `Program.cs`
public ExempleController(HttpClient client, MaClasse mc)
{
client = client;
_maClasse = mc;
}
}
}
Configuration
Certaine variable de configuration ne doivent pas être stocké dans le code source.
Soit parce qu’elles sont sensible (mot de passe, clé d’API) soit parce qu’elles peuvent changer sans recompiler le code (adresse de la base de donnée, adresse d’un service externe).
Pour cela on va stocker ces variables dans un fichier de configuration.
Ajouter une variable de configuration
Pour ajouter une variable de configuration on va ajouter une section dans le fichier appsettings.json.
{
"ConnectionStrings": {
"Sqlite": "Data Source=Confiture.db"
},
"APIKey": "abcedf"
}
Lire une variable de configuration
Pour lire une variable de configuration on va utiliser la classe Configuration fournie par le framework.
Pour se faire, ajouter un constructeur à votre classe et injecter la classe Configuration qui implémente IConfiguration.
public class RecetteService
{
private readonly string _connectionString;
private readonly string _apiKey;
public RecetteService(IConfiguration configuration)
{
_connectionString = configuration.GetConnectionString("Sqlite");
_apiKey = configuration["APIKey"];
}
}
Base de données
Quand une application a besoin de stocker puis de retrouver des informations sur la durée elle utilise en général une base de donnée.
Le framework ASP.Net Core nous permet facilement de se connecter a une BDD puis d’y faire des requêtes.
Les base de données supporté
Il existe plusieurs base supporté nottament:
- SQL Server
- Postgres
- MariaDB
- Mysql
- Sqlite
- MongoDB
On peux très facilement se connecter a d’autre base en ajoutant une dépendance via le système Nuget.
Sqlite
Cette base est particulièrement intéressante car elle n’a pas besoin de serveur pour fonctionner. En effet le stockage des information se fait dans un fichier sur le disque.
Cela est très pratique pour effectuer des tests ou pour des petites applications.
BDD en concept objet
Le stockage et la récupération des informations utilise les classes défini dans le projet. Il faudra donc définir une classe qui représente l’objet que l’on souhaite stocker.
Voici un exemple pour ajouter une base Sqlite a un projet.
Pour cet exemple nous gérerons des Confiture
public class Confiture
{
public int Id { get; set; }
public string Fruit { get; set; }
public int Annee { get; set; }
}
Maintenant que l’on a défini la structure de notre Confiture passons a la définition de notre BDD.
Instalation des dépendances
Pour pouvoir sauvegarder nos données, nous allons utiliser l’entity framework.
C’est un framework qui s’occupe d’abstraire les requêtes vers la base pour nous.
Pour cela, il faut l’ajouter à notre projet. Nous en profiterons pour ajouter dotnet ef qui permettra d’initialiser notre base de donnée
pour se faire, executer ces commandes dans le répértoire du projet depuis un terminal.
dotnet add package Microsoft.EntityFrameworkCore.Sqlite --version "11.0.0-rc.2.26504.105"
dotnet add package Microsoft.EntityFrameworkCore.Design --version "11.0.0-rc.2.26504.105"
dotnet tool install --global dotnet-ef --version "11.0.0-rc.2.26504.105"
Définir notre connection a une BDD
Pour défini une BDD, il faut créer une classe qui hérite de DbContext.
Le nom de cette nouvelle classe se termine en général par Context.
La classe doit posséder un constructeur.
Puis pour chaque type d’élement à stocker on va créer une variable de type DbSet<Type>
Voila donc a quoi ressemble une classe basique
using Microsoft.EntityFrameworkCore;
namespace ConfitureApi.Models;
public class ConfitureContext : DbContext
{
public ConfitureContext(DbContextOptions<ConfitureContext> options)
: base(options)
{
}
public DbSet<Confiture> Confitures { get; set; } = null!;
}
Configurer Sqlite
Notre base n’est actuellement pas configuré pour utiliser Sqlite.
On va ajouter une méthode OnConfiguring qui sera appelé pour configurer notre connection à la BDD.
Dans cette méthode on va spécifier que l’on désire utiliser Sqlite et on donnera le lien vers le fichier de la base.
public class ConfitureContext : DbContext
{
public ConfitureContext(DbContextOptions<ConfitureContext> options)
: base(options)
{
}
protected override void OnConfiguring(DbContextOptionsBuilder options)
{
// Connexion a la base sqlite
options.UseSqlite("Data Source=Confiture.db");
}
public DbSet<Confiture> Confitures { get; set; } = null!;
}
Initialiser la BDD au lancement
Pour que notre programme se connecte a notre BDD il faut le lui demander.
Cela se passe dans la phase de configuration dans Program.cs
builder.Services.AddDbContext<ConfitureContext>();
Les Migrations
On va créer un fichier de migration qui nous permettra de créer la structure de notre base.
Une migration est un fichier qui permet de faire passer une base d’un état A à un état B mais également de revenir à l’état A en efféctuant les opérations inverse.
Dans notre cas, ce premier fichier de migration va servir a créer notre table Confitures avec ses champs.
La encore, c’est une commande qui va nous aider
dotnet ef migrations add InitialisationDeLaDB
Un nouveau dossier Migrations a du apparaitre. A l’intérieur 3 fichiers dont un qui devrait ressembler a ca :
using Microsoft.EntityFrameworkCore.Migrations;
#nullable disable
namespace ConfitureApi.Migrations
{
/// <inheritdoc />
public partial class Init : Migration
{
/// <inheritdoc />
protected override void Up(MigrationBuilder migrationBuilder)
{
// La liste des opérations à executer pour créer notre table Confitures
}
/// <inheritdoc />
protected override void Down(MigrationBuilder migrationBuilder)
{
// Les opération inverse, donc ici la suppression de la table Confitures
}
}
}
Création de la BDD
Notre applicatif connait désormais notre BDD et s’y connecte au démarrage.
Mais elle n’existe pas encore cette BDD !
dotnet ef database update
Cette commande va commencer par créer notre BDD Sqlite si elle n’existe pas.
Puis elle va y appliquer les migrations une par une dans l’ordre.
Dans notre cas, une seul migration sera appliqué, pour créer notre table Confitures.
Utiliser la BDD dans un controlleur
using Microsoft.EntityFrameworkCore;
Pour accéder à notre BDD dans un controlleur il faut injecter notre contexte dans le constructeur. On créer une variable privée pour stocker le contexte et on l’initialise dans le constructeur.
using ConfitureApi.Models;
namespace ConfitureApi.Controllers;
[Route("api/[controller]")]
[ApiController]
public class ConfitureController : ControllerBase
{
private readonly ConfitureContext _context;
public ConfitureController(ConfitureContext ctx)
{
_context = ctx;
}
}
Récupérer des données
Pour récupérer des données de notre BDD on va utiliser la méthode Find de notre contexte.
[HttpGet("{id}")]
public async Task<ActionResult<Confiture>> GetConfiture(int id)
{
// on récupère la confiture correspondant a l'id
var confiture = await _context.Confitures.FindAsync(id);
if (confiture == null)
{
return NotFound();
}
// on retourne la confiture
return Ok(confiture);
}
Ajouter des données
Pour ajouter des données dans notre BDD on va utiliser la méthode Add de notre contexte.
Puis on va appeler la méthode SaveChanges pour enregistrer les modifications.
On peux ensuite retourner un code 201 pour indiquer que la création a bien eu lieu.
class ConfitureCreation
{
public string Fruit { get; set; }
public int Annee { get; set; }
}
[HttpPost]
public async Task<ActionResult<Confiture>> PostConfiture(ConfitureCreation confitureCreation)
{
// on créer une nouvelle confiture avec les informations reçu
Confiture confiture = new Confiture {
Fruit = confitureCreation.Fruit,
Annee = confitureCreation.Annee
};
// on l'ajoute a notre contexte (BDD)
_context.Confitures.Add(confiture);
// on enregistre les modifications dans la BDD ce qui remplira le champ Id de notre objet
await _context.SaveChangesAsync();
// on retourne un code 201 pour indiquer que la création a bien eu lieu
return CreatedAtAction(nameof(GetConfiture), new { id = confiture.Id }, confiture);
}
Mettre a jour des données
Pour mettre a jour des données dans notre BDD on va utiliser la méthode Update de notre contexte.
Puis on va appeler la méthode SaveChanges pour enregistrer les modifications.
On peux ensuite retourner un code 204 pour indiquer que la modification a bien eu lieu.
Le code est un peu plus complexe car il faut vérifier que l’objet que l’on souhaite modifier n’a pas été modifié entre temps.
On utilise donc un try catch pour gérer l’erreur DbUpdateConcurrencyException.
[HttpPut("{id}")]
public async Task<IActionResult> PutConfiture(int id, Confiture confitureUpdate)
{
// on récupère la confiture que l'on souhaite modifier
var confiture = await _context.Confitures.FindAsync(id);
if (confiture == null)
{
return NotFound();
}
// on met a jour les informations de la confiture
confiture.Fruit = confitureUpdate.Fruit;
confiture.Annee = confitureUpdate.Annee;
try
{
// on enregistre les modifications
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
// si une erreur de concurrence survient on retourne un code 409
return Conflict("Erreur de concurrence");
}
// on retourne un code 200 pour indiquer que la modification a bien eu lieu
return Ok(confiture);
}
Supprimer des données
Pour supprimer des données dans notre BDD on va utiliser la méthode Remove de notre contexte.
Puis on va appeler la méthode SaveChanges pour enregistrer les modifications.
On peux ensuite retourner un code 204 pour indiquer que la suppression a bien eu lieu.
[HttpDelete("{id}")]
public async Task<IActionResult> DeleteConfiture(int id)
{
// on récupère la confiture que l'on souhaite supprimer
Confiture confiture = await _context.Confitures.FindAsync(id);
if (confiture == null)
{
return NotFound();
}
// on indique a notre contexte que l'objet a été supprimé
_context.Confitures.Remove(confiture);
// on enregistre les modifications
await _context.SaveChangesAsync();
// on retourne un code 204 pour indiquer que la suppression a bien eu lieu
return NoContent();
}
Conclusion
Les bases de données sont un élément essentiel de toute application.
ASP.Net Core nous permet de facilement nous connecter a une base et d’y effectuer des opérations sans intégrer de logique sépcifique à la base choisi.
Authentification
L’authentification est une étape importante dans le développement d’une application. Elle permet de vérifier l’identité de l’utilisateur et de lui donner accès à certaines ressources. Dans ce chapitre, nous allons voir comment mettre en place un système d’authentification dans une application ASP.NET.
Nous utiliserons JWT (JSON Web Token) pour sécuriser nos API et nos pages web. JWT est un standard ouvert qui permet de créer des jetons d’accès sécurisés et auto-suffisants. Il est basé sur JSON et est facile à utiliser dans différents langages de programmation.
JWT
dotnet add package Microsoft.AspNetCore.Authentication.JwtBearer --version "11.0.0-rc.2.26504.105"
Générer un JWT
Pour générer une JWT nous commençons par générer des Claims. Les Claims sont des informations sur l’utilisateur qui sont stockées dans le JWT. Par exemple, nous pouvons stocker l’identifiant de l’utilisateur, son nom, son email, etc.
using System.Security.Claims;
var claims = new[]
{
new Claim(ClaimTypes.NameIdentifier, "8"),
new Claim(ClaimTypes.Name, "Roger"),
new Claim(ClaimTypes.Role, "Admin"),
};
Un claim est composé d’un type et d’une valeur.
Le type et la valeur sont tout les deux des chaînes de caractères.
Il existe plusieurs types de claims prédéfinis dans .NET, utilisez l’enum ClaimTypes pour les utiliser.
Une fois les claims générés, nous allons créer une clé secrète pour signer le JWT. Injectez IConfiguration configuration dans le service qui génère le token, puis lisez la même valeur JWTKey pour générer et valider les tokens. Gardez la vraie clé hors du dépôt : en production, fournissez-la par une variable d’environnement nommée JWTKey.
using Microsoft.IdentityModel.Tokens;
string jwtKey = configuration["JWTKey"]
?? throw new InvalidOperationException("JWTKey is not configured");
SymmetricSecurityKey key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(jwtKey));
SigningCredentials credentials = new SigningCredentials(
key,
SecurityAlgorithms.HmacSha256
);
Enfin, nous allons créer un token avec les claims et la clé secrète.
using System.IdentityModel.Tokens.Jwt;
JwtSecurityToken token = new JwtSecurityToken(
issuer: "localhost:5000", // Qui émet le token ici c'est notre API
audience: "localhost:5000", // Qui peut utiliser le token ici c'est notre API
claims: claims, // Les informations sur l'utilisateur
expires: DateTime.UtcNow.AddMinutes(60), // Date d'expiration du token
signingCredentials: credentials // La clé secrète
);
string tokenString = new JwtSecurityTokenHandler().WriteToken(token);
Exemple de JWT
Voici un exemple de JWT.
eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6IjEiLCJodHRwOi8vc2NoZW1hcy54bWxzb2FwLm9yZy93cy8yMDA1LzA1L2lkZW50aXR5L2NsYWltcy9uYW1lIjoic3RyaW5nIiwiaHR0cDovL3NjaGVtYXMubWljcm9zb2Z0LmNvbS93cy8yMDA4LzA2L2lkZW50aXR5L2NsYWltcy9yb2xlIjoiQWRtaW4iLCJleHAiOjE3Mjk1OTc0NDUsImlzcyI6ImxvY2FsaG9zdDo1MDAwIiwiYXVkIjoibG9jYWxob3N0OjUwMDAifQ.S17n1mLz34r6Aipb_cbrMebDm4AESdqdF1Ge-XEckkI
Je vous invite a aller sur jwt.io pour décoder ce token et voir son contenu.
Valider un JWT
Nous savons désormais générer un JWT, mais comment s’en servir.
Il faut indiquer à notre API que nous voulons utiliser JWT pour sécuriser nos routes. Nous allons donc ajouter un middleware qui va vérifier la validité du JWT.
program.cs
using Microsoft.AspNetCore.Authentication.JwtBearer;
using Microsoft.IdentityModel.Tokens;
using System.Text;
builder.Services
.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
.AddJwtBearer(options =>
{
options.TokenValidationParameters = new TokenValidationParameters
{
ClockSkew = TimeSpan.FromMinutes(10), // Temps de tolérance pour la date d'expiration
ValidateLifetime = true, // Vérifie la date d'expiration
ValidateIssuerSigningKey = true, // Vérifie la signature
ValidAudience = "localhost:5000", // Qui peut utiliser le token ici c'est notre API
ValidIssuer = "localhost:5000", // Qui émet le token ici c'est notre API
IssuerSigningKey = new SymmetricSecurityKey(
Encoding.UTF8.GetBytes(builder.Configuration["JWTKey"]
?? throw new InvalidOperationException("JWTKey is not configured"))
),
RoleClaimType = ClaimTypes.Role // Dans quel claim est stocké le role
};
});
Via ce middleware, notre API va vérifier la validité du JWT à chaque requête. Si le JWT est valide, l’utilisateur pourra accéder à la ressource demandée. Sinon, il recevra une erreur 401.
Authentification
Activation de l’authentification
Maintenant que nous savons générer et valider un JWT, nous allons voir comment l’utiliser pour sécuriser nos routes.
Il faut d’abord activer l’authentification dans notre API.
program.cs
builder.Services.AddAuthorization();
...
app.UseAuthentication();
app.UseAuthorization();
Vérification de l’authentification
Pour vérifier l’authentification d’un utilisateur, nous allons ajouter un attribut [Authorize] sur les contrôleurs ou les actions que nous voulons sécuriser.
Voici un exemple d’utilisation de l’attribut [Authorize].
[Authorize] // Indique que l'on vérifie l'authentification de l'utilisateur dans ce contrôleur
[Route("api/[controller]")]
[ApiController]
public class AuthController : ControllerBase
{
[HttpGet]
[AllowAnonymous] // Permet d'accéder à cette route sans être authentifié
public IActionResult Anyone()
{
return Ok("Hello World");
}
[HttpGet]
[Authorize(Roles = "Admin")] // Permet d'accéder à cette route si l'utilisateur a le role Admin
public IActionResult Admin()
{
return Ok("Hello Admin");
}
[HttpGet]
[Authorize(Roles = "Admin, User")] // Permet d'accéder à cette route si l'utilisateur a le role Admin ou User
public IActionResult UserOrAdmin()
{
return Ok("Hello User or Admin");
}
[HttpGet]
[Authorize] // Permet d'accéder à cette route si l'utilisateur est authentifié peux importe son role
public IActionResult Authentified()
{
return Ok("Hello Authentified");
}
}
Récupération de l’utilisateur
Pour récupérer l’utilisateur qui a fait la requête, nous allons utiliser la propriété User de l’objet HttpContext.
Si l’on reprend les claims suivant :
var claims = new[]
{
new Claim(ClaimTypes.NameIdentifier, "8"),
new Claim(ClaimTypes.Name, "Roger"),
new Claim(ClaimTypes.Role, "Admin"),
};
Voici comment récupérer les informations de cet utilisateur quand il fait une requête.
[HttpGet]
[Authorize] // La route est sécurisée
public IActionResult Get()
{
int userId = int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value); // 8
string userName = User.FindFirst(ClaimTypes.Name).Value; // Roger
string userRole = User.FindFirst(ClaimTypes.Role).Value; // Admin
return Ok(new
{
Id = userId,
Name = userName,
Role = userRole
});
}
Password Hasher
Dans cette partie nous allons voir comment hasher un mot de passe pour le stocker en base de donnée.
Hasher un mot de passe
Pour hasher un mot de passe, on va utiliser la classe PasswordHasher<T> qui permet de dériver une clé à partir d’un mot de passe.
Prenons un classe User avec un champ Password :
public class User
{
public string Password { get; set; }
}
Pour hasher le mot de passe, on va utiliser la classe PasswordHasher<T> :
using Microsoft.AspNetCore.Identity;
var hasher = new PasswordHasher<User>();
var password = "LePasswordSecret";
var user = new User { Password = "" };
user.Password = hasher.HashPassword(user, password);
On peut maintenant vérifier si le mot de passe est correct :
var result = hasher.VerifyHashedPassword(user, user.Password, password);
if (result != PasswordVerificationResult.Failed)
{
Console.WriteLine("Mot de passe correct");
}
else
{
Console.WriteLine("Mot de passe incorrect");
}
CORS
CORS (Cross-Origin Resource Sharing) indique aux navigateurs quelles origines peuvent appeler une API depuis une page web. Il ne remplace pas l’authentification : un client hors navigateur peut toujours appeler l’API.
Documentation : https://developer.mozilla.org/en-US/docs/Web/HTTP/Guides/CORS
Configuration
Pour configurer CORS, nous allons utiliser la classe AddCors dans le fichier program.cs.
builder.Services.AddCors(options =>
{
options.AddPolicy("AllowAll", builder => builder.AllowAnyOrigin().AllowAnyHeader().AllowAnyMethod());
});
Pour utiliser CORS, nous allons ajouter le middleware UseCors dans le fichier program.cs.
app.UseCors("AllowAll");
Cela va permettre à toutes les origines de faire des requêtes vers notre API.
Pour limiter les origines qui peuvent faire des requêtes vers notre API, nous pouvons configurer une politique CORS.
builder.Services.AddCors(options =>
{
options.AddPolicy("AllowSpecificOrigin", builder => builder
.WithOrigins("https://csharp.nouvet.fr")
.AllowAnyHeader()
.AllowAnyMethod());
});
L’origine comprend le protocole, l’hôte et éventuellement le port, mais pas le chemin /front3. Cette politique autorise donc les pages de https://csharp.nouvet.fr à appeler l’API depuis un navigateur.
Pour utiliser une politique CORS, nous allons ajouter le middleware UseCors dans le fichier program.cs.
app.UseCors("AllowSpecificOrigin");
Validation des données
Pour valider les données, nous pouvons utiliser les annotations de data annotation.
[Required]
public string Nom { get; set; }
Ici le champ Nom est obligatoire.
Vous pouvez également utiliser les annotations suivantes:
- [Key] : Le champ est la clé primaire de la table
- [Required] : Le champ est obligatoire
- [MinLength(3)] : Le champ doit avoir une longueur minimale de 3 caractères
- [MaxLength(100)] : Le champ doit avoir une longueur maximale de 100 caractères
- [EmailAddress] : Le champ doit être une adresse email valide
- [RegularExpression(@“^[a-zA-Z0-9]+$”)] : Le champ doit comporter uniquement des lettres et des chiffres
Voici un exemple avec la classe Confiture:
public class Confiture
{
[Key]
public int Id { get; set; }
[Required]
[MinLength(3)]
[MaxLength(100)]
public string Fruit { get; set; }
[Required]
[Range(1900, 2100)]
public int Annee { get; set; }
public Confiture(int id, string fruit, int annee)
{
Id = id;
Fruit = fruit;
Annee = annee;
}
}
La liste des annotations de data annotation est disponible ici.
Les Middlewares
Dans ASP.NET Core, le pipeline de traitement des requêtes (Request Pipeline) est composé d’une série de composants appelés Middlewares.
Chaque middleware intercepte la requête HTTP entrant, peut effectuer des opérations avant et après le middleware suivant, et décide de passer ou non la requête au suivant.
Le Pipeline
Imaginez le pipeline comme une série de couches d’oignon ou de filtres.
- La requête arrive.
- Elle traverse le Middleware 1.
- Elle traverse le Middleware 2.
- …
- Elle atteint le Endpoint (votre Controller).
- Le Controller génère une réponse.
- La réponse repasse par le Middleware 2 (en sens inverse).
- La réponse repasse par le Middleware 1.
- La réponse est envoyée au client.
Utilisation standard
Vous utilisez déjà des middlewares sans le savoir dans Program.cs :
var app = builder.Build();
// Middleware de redirection HTTPS
app.UseHttpsRedirection();
// Middleware d'autorisation
app.UseAuthorization();
// Middleware qui mappe les controllers aux routes
app.MapControllers();
app.Run();
L’ordre de déclaration dans Program.cs est CRUCIAL. Si UseAuthorization est placé avant UseAuthentication (qui décode le user), l’autorisation échouera car l’utilisateur ne sera pas encore connu.
Créer un Middleware personnalisé
Pour des besoins spécifiques (Logging global, Gestion d’erreur globale, Headers de sécurité), on peut créer nos propres middlewares.
Un middleware est généralement une classe qui possède :
- Un constructeur prenant un
RequestDelegate(le pointeur vers le middleware suivant). - Une méthode
InvokeAsyncprenant leHttpContext.
public class SimpleLoggerMiddleware
{
private readonly RequestDelegate _next;
public SimpleLoggerMiddleware(RequestDelegate next)
{
_next = next;
}
public async Task InvokeAsync(HttpContext context)
{
// Avant le controller : On log la requête
Console.WriteLine($"Request: {context.Request.Method} {context.Request.Path}");
// On passe la main au middleware suivant
await _next(context);
// Après le controller : On log le status code
Console.WriteLine($"Response: {context.Response.StatusCode}");
}
}
Enregistrement
Pour utiliser ce middleware, on l’ajoute dans Program.cs :
app.UseMiddleware<SimpleLoggerMiddleware>();
Cas d’usage : Gestion globale des erreurs
Plutôt que de mettre des try/catch dans chaque méthode de vos controllers, vous pouvez utiliser un middleware qui englobe toute l’exécution.
Si une exception “remonte” jusqu’au middleware sans être attrapée, le middleware peut l’intercepter, formatter une belle réponse JSON d’erreur, et renvoyer un code HTTP approprié (500, 400, 404).
Cela permet de garder vos controllers propres et focalisés sur la logique métier.
Changer le code de retour et le contenu depuis un middleware
Voici comment fonctionne le code ci-dessous :
Dans un middleware, vous pouvez modifier le code de retour HTTP (StatusCode) et le contenu de la réponse. Par exemple, ici :
context.Response.StatusCode = statusCode;: fixe le code HTTP de réponse (ex : 200, 400, 500, …).context.Response.ContentType = "application/json";: indique que la réponse sera du JSON.await context.Response.WriteAsync(...): écrit le contenu dans la réponse. Ici on utiliseJsonSerializer.Serialize(...)pour transformer un objet .NET en JSON.
Ce modèle permet donc de gérer proprement les erreurs côté serveur :
- On choisit le code de retour HTTP,
- On construit une réponse structurée (souvent avec un message, un code d’erreur, etc.),
- On l’envoie au format JSON à l’utilisateur.
C’est la base de la gestion d’erreur globale par middleware, pour retourner des messages d’erreur uniformisés à toutes les erreurs non attrapées ailleurs.
// On configure les options de sérialisation pour avoir un JSON en camelCase comme dans les contrôleurs
var option = new JsonSerializerOptions
{
PropertyNamingPolicy = JsonNamingPolicy.CamelCase
};
context.Response.StatusCode = 500;
context.Response.ContentType = "application/json";
await context.Response.WriteAsync(
JsonSerializer.Serialize(new { Message = "Erreur interne", Code = "INTERNAL_SERVER_ERROR" }, option)
);
Le code ci-dessus est un exemple de comment on peut changer le code de retour et le contenu de la réponse depuis un middleware.
Architecture : Services et Injection de Dépendance
Au début d’un projet ASP.NET Core, on a tendance à écrire toute la logique métier directement dans les méthodes des Contrôleurs. C’est ce qu’on appelle l’anti-pattern “Fat Controller”.
Pourquoi séparer le code ?
Les contrôleurs ont pour unique responsabilité de gérer le protocole HTTP :
- Recevoir la requête (et désérialiser le JSON).
- Valider les entrées basiques.
- Appeler la logique métier.
- Renvoyer une réponse HTTP appropriée (200 OK, 404 Not Found, etc.).
Ils ne devraient JAMAIS contenir :
- La logique de calcul (ex: formule du coût du reset).
- Les appels directs à la base de données (si possible).
- La logique de validation complexe (ex: vérifier si l’utilisateur a assez d’argent).
Cette séparation permet de :
- Tester la logique métier sans lancer un serveur web (Tests Unitaires).
- Réutiliser la logique métier ailleurs (ex: dans une tâche planifiée).
- Lire plus facilement le code.
Création d’un Service
Un service est une classe C# standard qui contient la logique métier.
Exemple : GameService.cs
using GameServerApi.Models;
using Microsoft.EntityFrameworkCore;
namespace GameServerApi.Services;
public class GameService
{
private readonly BDDContext _context;
public GameService(BDDContext context)
{
_context = context;
}
public async Task<Progression> ClickAsync(int userId)
{
var progression = await _context.Progressions.FirstOrDefaultAsync(p => p.UserId == userId);
if (progression == null)
{
throw new Exception("Progression introuvable");
}
progression.Count += (1 + progression.TotalClickValue) * progression.Multiplier;
await _context.SaveChangesAsync();
return progression;
}
}
Injection de Dépendance (DI)
Pour utiliser ce service dans un contrôleur, il faut l’enregistrer dans le conteneur de dépendances.
Dans Program.cs :
// Enregistrement du service
// AddScoped : Une nouvelle instance est créée pour chaque requête HTTP
builder.Services.AddScoped<GameService>();
Ensuite, on l’injecte dans le constructeur du contrôleur :
using System.Security.Claims;
using GameServerApi.Services;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
namespace GameServerApi.Controllers;
[Authorize]
[ApiController]
[Route("api/[controller]")]
public class GameController : ControllerBase
{
private readonly GameService _gameService;
public GameController(GameService gameService)
{
_gameService = gameService;
}
[HttpGet("Click")]
public async Task<IActionResult> Click()
{
var idClaim = User.FindFirst(ClaimTypes.NameIdentifier)?.Value;
if (!int.TryParse(idClaim, out int userId)) return Unauthorized();
var progression = await _gameService.ClickAsync(userId);
return Ok(new
{
count = progression.Count,
multiplier = progression.Multiplier,
totalClickValue = progression.TotalClickValue
});
}
}
Refactoring étape par étape
- Identifiez un bloc de logique dans votre contrôleur.
- Créez une méthode dans un Service correspondant (
UserService,GameService,InventoryService). - Déplacez le code (et les dépendances comme le
DbContext) dans ce Service. - Appelez le Service depuis le Contrôleur.
Votre contrôleur va maigrir et devenir beaucoup plus clair !
Transactions et Concurrence
Dans un environnement web, plusieurs utilisateurs peuvent faire des requêtes simultanément. Pire, un même utilisateur peut envoyer la même requête plusieurs fois très rapidement (double-clic, script, lag).
Cela peut causer des problèmes graves d’intégrité des données, appelés Race Conditions (Conditions de concurrence).
Le problème
Imaginons la fonction “Acheter un objet” :
- Lire le solde de l’utilisateur (ex: 100 pièces).
- Vérifier si le solde >= prix (ex: 50 pièces).
- Déduire le prix (Nouveau solde = 50).
- Sauvegarder le solde.
- Ajouter l’objet à l’inventaire.
Si deux requêtes arrivent exactement en même temps :
- Requête A lit le solde : 100.
- Requête B lit le solde : 100 (car A n’a pas encore sauvegardé !).
- Requête A déduit 50 et sauvegarde -> Solde 50.
- Requête B déduit 50 et sauvegarde -> Solde 50.
- Résultat : L’utilisateur a payé 50 pièces au total mais a reçu l’objet deux fois ! Il aurait dû payer 100.
Solution 1 : Les Transactions
Une transaction garantit que plusieurs opérations de base de données sont traitées comme une seule unité indivisible (Atomicité).
Si une erreur survient au milieu, tout est annulé (Rollback).
Avec Entity Framework Core, dans une méthode async d’InventoryService où _context est injecté et userId et itemId sont les paramètres :
await using var transaction = await _context.Database.BeginTransactionAsync();
try
{
// Exemple simplifié : l'objet n'est pas encore dans l'inventaire.
var progression = await _context.Progressions.SingleAsync(p => p.UserId == userId);
var item = await _context.Items.FindAsync(itemId)
?? throw new InvalidOperationException("Objet introuvable");
if (progression.Count < item.Price)
throw new InvalidOperationException("Points insuffisants");
progression.Count -= item.Price;
progression.TotalClickValue += item.ClickValue;
_context.Inventories.Add(new InventoryEntry
{
UserId = userId,
ItemId = itemId,
Quantity = 1
});
await _context.SaveChangesAsync();
// Si on arrive ici sans erreur, on valide tout
await transaction.CommitAsync();
}
catch
{
// En cas d'erreur, tout est annulé automatiquement
// (Le Rollback est implicite si on ne commit pas, mais on peut le forcer)
await transaction.RollbackAsync();
throw;
}
Cependant, les transactions seules ne résolvent pas toujours le problème de lecture concurrente (Requête B qui lit 100 alors que A est en train de modifier). Il faut souvent changer le Niveau d’Isolation de la transaction (ex: Serializable), ce qui peut ralentir la base de données.
Solution 2 : Concurrence Optimiste
La concurrence optimiste part du principe que les conflits sont rares. On laisse tout le monde lire, mais au moment d’écrire, on vérifie si la donnée a changé entre temps.
On ajoute souvent un jeton de concurrence (ex: RowVersion ou Timestamp) dans la table.
public class User
{
public int Id { get; set; }
public int Money { get; set; }
[Timestamp]
public byte[] RowVersion { get; set; }
}
Lors de l’update :
UPDATE Users SET Money = 50 WHERE Id = 1 AND RowVersion = [AncienneValeur]
Si quelqu’un d’autre a modifié la ligne entre temps, le RowVersion a changé. La clause WHERE ne trouve aucune ligne, et EF Core lance une DbUpdateConcurrencyException.
Il suffit d’attraper cette exception et de dire à l’utilisateur : “Oups, réessayez svp”.
Projet
Le but du projet est de créer l’API d’un jeu de clics en ASP.NET Core.
Un joueur pourra créer un compte, cliquer pour gagner des points, acheter des objets qui augmentent la valeur de ses clics et réinitialiser sa progression pour améliorer son multiplicateur. L’API conservera les utilisateurs, les scores et les inventaires dans une base de données.
Les versions du frontend fournies chaque semaine permettent de tester l’API. Le projet à réaliser dans ce cours est le service web ; aucun site Blazor n’est demandé.
Semaine 1
Initialisation
Avant de commencer, suivez les instructions d’installation du SDK .NET et de configuration de l’IDE.
Depuis le dossier qui contiendra votre solution, créez une solution .NET nommée IncrementalGame (vous pouvez choisir un autre nom). La commande génère IncrementalGame.slnx, au format XML utilisé par défaut par les SDK .NET récents. Une solution regroupe les projets ; chaque projet possède son propre fichier .csproj.
dotnet new sln -n IncrementalGame
Depuis le même dossier, créez un projet (vous pouvez choisir un autre nom que GameServerApi). Les options de cette commande sont détaillées dans le chapitre Création d’un projet API.
dotnet new webapi --framework net11.0 --use-controllers --no-https -n GameServerApi
Par défaut, Program.cs utilise des instructions de premier niveau : le compilateur génère le point d’entrée. Vous pouvez ajouter l’option --use-program-main à la commande de création si vous préférez une classe Program et une méthode Main explicites. Dans ce cas, placez le code de démarrage des exemples dans Main et les directives using en haut du fichier. Voir le chapitre Main et instructions de premier niveau.
Depuis le dossier de la solution, ajoutez le projet à IncrementalGame.slnx :
dotnet sln add GameServerApi
Si cela a fonctionné vous devriez vous retrouver avec les fichiers suivants dans le dossier GameServerApi:
appsettings.Development.json
appsettings.json
bin/
Controllers/
| WeatherForecastController.cs
obj/
Program.cs
GameServerApi.csproj
GameServerApi.http
Properties/
WeatherForecast.cs
Dotnet CLI
Depuis le dossier de la solution (celui qui contient IncrementalGame.slnx), compilez les projets de la solution :
dotnet build
Pour compiler puis démarrer l’API depuis ce même dossier, indiquez le projet à lancer :
dotnet run --project GameServerApi/
L’option --project indique le chemin du dossier contenant le fichier .csproj. Adaptez ce chemin si vous avez choisi un autre nom de projet.
Pour relancer automatiquement l’application lors des modifications, toujours depuis le dossier de la solution :
dotnet watch --project GameServerApi/
Si votre terminal est déjà dans le dossier du projet GameServerApi, les commandes courtes dotnet build, dotnet run et dotnet watch suffisent. Sans --project, dotnet run et dotnet watch cherchent le projet dans le dossier courant. Arrêtez l’application avec Ctrl+C avant de la relancer.
Fixer le port de l’application
Pour retrouver votre API à la même adresse à chaque lancement, ouvrez GameServerApi/Properties/launchSettings.json. Dans le profil http, définissez applicationUrl sur http://localhost:5000 :
{
"$schema": "https://json.schemastore.org/launchsettings.json",
"profiles": {
"http": {
"commandName": "Project",
"dotnetRunMessages": true,
"launchBrowser": true,
"applicationUrl": "http://localhost:5000",
"launchUrl": "scalar/v1",
"environmentVariables": {
"ASPNETCORE_ENVIRONMENT": "Development"
}
}
}
}
applicationUrl fixe l’adresse et le port d’écoute de l’API. launchUrl indique seulement la page à ouvrir dans le navigateur : ici, l’interface Scalar une fois configurée dans la section suivante.
Arrêtez l’application avec Ctrl+C, puis relancez-la depuis le dossier de la solution en sélectionnant le profil http :
dotnet run --project GameServerApi/ --launch-profile http
Vérifiez que le terminal affiche Now listening on: http://localhost:5000. Votre API utilise désormais le port 5000. Si ce port est déjà occupé, choisissez un autre port libre dans applicationUrl, puis redémarrez l’application.
Ce fichier configure le lancement en développement local ; il ne configure pas le port de l’application déployée. Consultez la documentation des profils de lancement pour en savoir plus.
Les paquets .NET avec NuGet
Un paquet est une bibliothèque que vous pouvez ajouter à votre projet pour utiliser des fonctionnalités existantes. .NET utilise le gestionnaire de paquets NuGet ; les paquets publics sont disponibles sur nuget.org.
Pour installer un paquet, exécutez cette commande depuis le dossier contenant le fichier .csproj, en remplaçant NomDuPaquet par son nom :
dotnet add package NomDuPaquet
La commande ajoute une référence au paquet dans le fichier .csproj et télécharge ses dépendances, les autres paquets nécessaires à son fonctionnement. Pour choisir une version précise, ajoutez --version NumeroDeVersion. Après avoir récupéré un projet, dotnet restore télécharge les paquets référencés ; cette restauration est aussi effectuée automatiquement par dotnet build et dotnet run.
Dans la partie suivante, nous allons installer le paquet Scalar.AspNetCore pour ajouter une interface de test à notre API.
Tester l’API avec Scalar
Scalar fournit une interface web pour consulter les routes de votre API et leur envoyer des requêtes. Mettez-le en place dès maintenant pour tester l’API générée, avant de créer votre contrôleur User.
Suivez le chapitre Scalar pour installer le paquet Scalar.AspNetCore, configurer OpenAPI et Scalar dans Program.cs, puis ouvrir automatiquement son interface avec Properties/launchSettings.json. Exécutez la commande d’installation du paquet depuis le dossier GameServerApi, qui contient le fichier .csproj.
Lancez ensuite l’API depuis le dossier de la solution :
dotnet run --project GameServerApi/ --launch-profile http
Ouvrez l’adresse HTTP affichée dans le terminal en ajoutant /scalar/v1 à la fin, http://localhost:5000/scalar/v1 si vous avez conservé le port défini dans la section précédente.
Dans Scalar, ouvrez la route GET du contrôleur WeatherForecast et envoyez une requête. Vérifiez que vous recevez une réponse HTTP 200 contenant des prévisions météo au format JSON. Ce premier test confirme que l’API et son interface de test fonctionnent avant de poursuivre.
Structure
Consultez le chapitre Structure d’un projet Web API pour comprendre le rôle des fichiers et des dossiers générés.
Une fois le projet créé je vous invite a créer un dossier Models dans lequel seront stocké les classes de notre projet.
Vous pouvez dès a présent y déplacer WeatherForecast.cs
Gardez le contrôleur WeatherForecast et sa classe comme exemple jusqu’au premier test réussi de votre contrôleur User. Vous pourrez ensuite les supprimer.
Création d’un Controller
Vous allez désormais pouvoir créer votre propre Controller. Le chapitre Contrôleur explique sa structure et les annotations utilisées pour définir les routes.
Pour cela c’est assez simple il existe une commande dotnet.
Il s’agit de dotnet new apicontroller
Elle prend plusieurs paramètres dont:
-n: Le nom du controller-p:n: Le namespace du controller-ac: Si vous voulez ajouter des actions CRUD (Create, Read, Update, Delete)-o: Le dossier dans lequel vous voulez créer le controller
Pour créer un controller User dans le dossier Controllers avec des actions CRUD, exécutez la commande suivante depuis le dossier du projet GameServerApi (celui qui contient GameServerApi.csproj). Si vous êtes dans le dossier de la solution, entrez d’abord dans le projet avec cd GameServerApi :
dotnet new apicontroller -n UserController -p:n GameServerApi.Controllers -ac true -o Controllers
Si vous connaissez la structure du controller, vous pouvez très bien créer le fichier à la main. Il est aussi possible de copier un controller existant et de le modifier.
Utilisateur
Vous devrez créer une classe Utilisateur dans le dossier Models (Models/User.cs). Pour définir ses données, appuyez-vous sur les chapitres Types des variables et Propriétés.
Un utilisateur sera caractérisé par :
- Son Id
- Son pseudo
- Son mot de passe
- Son rôle (User, Admin)
Pour le rôle, utilisez une énumération nommée Role, avec les valeurs User = 0 et Admin = 1. Nommez les propriétés Id (int), Pseudo (string), Password (string) et Role (Role).
User Controller
Votre premier controller aura pour rôle de gérer les utilisateurs.
Le chapitre Méthodes HTTP rappelle le rôle de GET et de POST. Pour choisir les réponses de vos actions, consultez les Codes de retour d’un contrôleur.
Il devra fournir les endpoints suivants:
GET /api/User/{id} // Renvoi l'utilisateur correspondant à l'id
POST /api/User/Register // Renvoi l'utilisateur dont on demande la création
POST /api/User/Login // Renvoi l'utilisateur
GET /api/User/All // Renvoi une liste d'utilisateurs
Pour les endpoints Register et Login, ils prendront en paramètre une classe UserInfo qui contiendra le pseudo et le mot de passe. La partie Envoyer de la donnée montre comment recevoir un objet dans une action POST.
Le controlleur retournera une classe UserPublic quand il devra retourner un utilisateur, cette classe est similaire a User mais sans le mot de passe.
Une fausse base de données en mémoire
Pour cette première semaine, utilisez une liste static dans UserController pour stocker les utilisateurs :
private static readonly List<User> _users = new();
Le mot-clé static signifie que la liste appartient à la classe : toutes les instances de UserController partagent la même liste. Ainsi, un utilisateur ajouté lors d’une requête reste disponible pour les requêtes suivantes. Avec un simple champ d’instance, la liste ne serait pas partagée entre les instances du contrôleur. readonly empêche de remplacer la liste par une autre, mais permet toujours d’y ajouter des utilisateurs.
Consultez le chapitre Collections pour manipuler une List<User>.
La liste est vide au démarrage. Pour attribuer des identifiants, ajoutez un compteur partagé, initialisé à 1 :
private static int _nextId = 1;
Lors de l’inscription, attribuez la valeur de _nextId au nouvel utilisateur, puis incrémentez le compteur. Le rôle attribué par le serveur sera toujours Role.User.
Cette liste simule une base de données : elle reste en mémoire uniquement pendant l’exécution de l’application. Un redémarrage, y compris lors d’un rechargement par dotnet watch, vide la liste et réinitialise le compteur. Nous la remplacerons par une base de données en semaine 2. Pour cet exercice, effectuez les requêtes une par une : la liste et le compteur ne gèrent pas les modifications concurrentes.
Comportement attendu des routes
| Route | Comportement | Réponse HTTP |
|---|---|---|
GET /api/User/{id} | Chercher un utilisateur dans la liste par son identifiant et renvoyer un UserPublic. | 200, ou 404 si aucun utilisateur ne correspond. |
GET /api/User/All | Renvoyer les utilisateurs de la liste sous forme de UserPublic. | 200, avec [] si la liste est vide. |
POST /api/User/Register | Recevoir un UserInfo, créer un User, lui attribuer un identifiant et le rôle User, l’ajouter à la liste et renvoyer un UserPublic. | 200. |
POST /api/User/Login | Recevoir un UserInfo, chercher un utilisateur dont le pseudo et le mot de passe correspondent et renvoyer un UserPublic. | 200, ou 401 si les identifiants ne correspondent pas. |
Exemple de corps JSON pour Register et Login :
{
"pseudo": "Alice",
"password": "exemple-fictif"
}
Exemple de réponse après la première inscription :
{
"id": 1,
"pseudo": "Alice",
"role": 0
}
Par défaut, l’énumération est représentée par un nombre dans le JSON : 0 correspond à Role.User. Ne renvoyez jamais directement un User : construisez un UserPublic pour chaque utilisateur retourné, y compris dans la liste de All.
Utilisez uniquement des mots de passe fictifs pour cette simulation. Le hachage des mots de passe sera introduit en semaine 2 ; aucun token JWT n’est demandé cette semaine. La gestion des pseudos en double reste hors du périmètre de cette séance.
Vérification finale et livrables
Une fois votre contrôleur User terminé, relancez l’API et ouvrez Scalar. Vérifiez que ses quatre routes apparaissent, puis réalisez le scénario suivant sans redémarrer l’application entre les requêtes :
- Appelez
All: la réponse doit être200avec une liste vide[]. - Inscrivez Alice avec
Register: vérifiez le code200, l’identifiant attribué, le rôle0et l’absence du mot de passe dans la réponse. - Appelez
GET /api/User/{id}avec cet identifiant, puisAll: Alice doit apparaître dans les deux réponses. - Appelez
Loginavec les mêmes identifiants : vous devez recevoir200et les informations publiques d’Alice. Avec un mauvais mot de passe, vous devez recevoir401. - Demandez un identifiant inexistant : vous devez recevoir
404. - Redémarrez l’application, puis appelez
All: la liste doit être à nouveau vide.
À la fin de la séance, vous devez avoir :
- Une solution
IncrementalGame.slnxcontenant le projetGameServerApi, qui compile sans erreur. - Une API accessible sur le port choisi et une interface Scalar fonctionnelle.
- Les modèles
User,UserInfo,UserPublicet une énumération pour les rôles. - Les quatre routes de
UserControllertestées dans Scalar, avec une listestaticpartagée comme fausse base de données et aucun mot de passe retourné.
Conservez un exemple de requête et de réponse pour chaque route, avec le code HTTP obtenu. Vous devez pouvoir expliquer le chemin d’une requête : méthode et URL, action du contrôleur appelée, données reçues et réponse renvoyée.