1. Constructeurs simples
Un constructeur — c'est une méthode spéciale d'une classe qui est appelée automatiquement quand tu crées un objet. Il initialise (configure) l'objet : il définit les valeurs de départ, fait des vérifs, et peut même te remonter le moral si tu mets une blague dedans.
Le constructeur te permet de créer direct un objet dans un certain état, au lieu de devoir tout lui assigner à la main via les champs et propriétés. C'est pratique et safe, parce que tu donnes tout de suite tous les paramètres importants — et t'oublies rien de critique.
Sans constructeur, le code peut vite devenir lourd et sujet aux bugs :
Person p = new Person();
p.Name = "Yulia";
p.Age = 25; // Et si on oublie de mettre l'âge ?
Avec un constructeur :
Person p = new Person("Yulia", 25); // Tout est passé d'un coup et l'objet est prêt à vivre !Syntaxe du constructeur
Un constructeur — c'est une sorte de "méthode" spéciale, dont le nom est exactement le même que celui de la classe et qui n'a pas de valeur de retour (même pas void). Voilà à quoi ressemble un constructeur par défaut :
public class Person
{
// Constructeur par défaut (sans paramètres)
public Person()
{
// Ici tu peux mettre du code d'initialisation
}
}
Le constructeur par défaut — c'est un genre "d'assistant" invisible, qui ne prend aucun paramètre et initialise juste tous les champs et propriétés de ta classe avec leurs valeurs par défaut :
- Pour les types numériques (int, double, float, etc.), ce sera 0.
- Pour le type booléen (bool), c'est false.
- Pour les types référence (string, autres classes), c'est null (ça veut dire "rien", "pas de référence sur un objet").
- Pour DateTime ce sera 01.01.0001 00:00:00.
Comment appeler un constructeur ?
En fait, quand tu écris l'opérateur new pour créer un objet, tu appelles le constructeur !
Person p = new Person();
Si tu ne définis pas explicitement de constructeur, le compilateur C# va te générer un constructeur par défaut (sans paramètres). Mais si tu déclares au moins un constructeur à toi — le constructeur par défaut disparaît, et le compilateur va te demander d'être honnête et de l'ajouter à la main si tu en as besoin.
Exemple
Allez, on ajoute un constructeur à la classe de notre appli. Voilà une version simple d'une classe étudiant :
public class Student
{
public string Name;
public int Age;
// Constructeur avec deux paramètres (nom et âge)
public Student(string name, int age)
{
Name = name; // On assigne la valeur au champ
Age = age;
}
}
Maintenant tu peux créer un étudiant comme ça :
Student s = new Student("Ivan", 21);
Console.WriteLine($"{s.Name}: {s.Age} ans"); // Ivan: 21 ans
- On a déclaré le constructeur avec la même visibilité (public) que la classe elle-même.
- Dans le constructeur, on assigne les valeurs aux champs en utilisant les paramètres reçus.
- Cette approche protège contre les oublis : le compilateur va t'obliger à donner le nom et l'âge à la création de l'objet.
2. Paramètres du constructeur
En C#, tu peux déclarer plusieurs constructeurs avec des ensembles de paramètres différents. Ça s'appelle la surcharge de constructeur (on parlera aussi de la surcharge de méthodes plus tard).
Par exemple, ajoutons un constructeur sans paramètres :
public class Student
{
public string Name;
public int Age;
// Constructeur par défaut
public Student()
{
Name = "SansNom";
Age = 0;
}
// Constructeur avec paramètres
public Student(string name, int age)
{
Name = name;
Age = age;
}
}
Maintenant les deux variantes sont possibles :
Student s1 = new Student(); // Nom : SansNom, âge : 0
Student s2 = new Student("Olia", 22); // Nom : Olia, âge : 22
Utiliser le constructeur pour valider
Le constructeur — c'est l'endroit parfait pour vérifier la "qualité" des données reçues. Par exemple, un étudiant ne peut pas avoir un âge négatif !
public Student(string name, int age)
{
if (age < 0)
throw new ArgumentException("L'âge ne peut pas être négatif !");
Name = name;
Age = age;
}
Maintenant si quelqu'un essaie de créer un étudiant Student("Bébé", -2), l'appli va lancer une exception (ArgumentException). Cette approche est souvent utilisée pour garantir la fiabilité béton des données.
3. Initialisation d'objets complexes
Souvent, dans les applis réelles, un objet peut être "assemblé" non seulement à partir de types primitifs, mais aussi contenir d'autres objets :
public class Group
{
public string GroupName;
public Student[] Students;
public Group(string groupName, Student[] students)
{
GroupName = groupName;
Students = students;
}
}
Maintenant tu peux facilement créer un groupe avec une liste d'étudiants :
var students = new Student[]
{
new Student("Ivan", 20),
new Student("Maria", 19)
};
Group g = new Group("Groupe-101", students);
Initialisation des champs par défaut
Parfois, tu veux donner des valeurs par défaut à certains champs, si tous les paramètres ne sont pas passés au constructeur. Par exemple, si l'e-mail n'est pas obligatoire :
public Student(string name, int age)
{
Name = name;
Age = age;
Email = "inconnu@noemail.com"; // Valeur par défaut
}
4. Initialisation via Object Initializer
Avec les constructeurs, tu peux combiner une autre syntaxe pratique — les initialisateurs d'objet. Tu peux appeler le constructeur, puis dans les accolades, lister les valeurs des propriétés du nouvel objet :
public class Student
{
public string Name { get; set; }
public int Age { get; set; }
public string Email { get; set; }
// Le constructeur reste conseillé
public Student(string name, int age)
{
Name = name;
Age = age;
Email = "";
}
}
Student s = new Student("Anton", 18) { Email = "anton@domain.com" }; // constructeur + propriétés
Cette syntaxe marche super bien avec un constructeur, quand certains paramètres ont des valeurs par défaut ou ne sont pas toujours connus à la création.
5. Erreurs typiques et particularités
Quand tu bosses avec les constructeurs, les débutants tombent souvent sur quelques erreurs classiques. On va les décortiquer simplement :
Erreur n°1 : Noms qui ne correspondent pas
Parfois on confond les noms des paramètres et des champs, surtout s'ils ne diffèrent que par la casse.
public Student(string Name, int Age) // Avec une majuscule !
{
Name = Name; // Oups ! Les deux Name pointent sur le paramètre. Le champ reste non initialisé.
}
La bonne façon : Utiliser this pour référencer le champ de l'objet :
public Student(string name, int age)
{
this.Name = name;
this.Age = age;
}
Ou alors choisir des noms différents (genre nameParam, ageParam), mais la pratique avec this. est considérée comme un bon style, surtout dans les gros projets.
Erreur n°2 : Pas de constructeur par défaut
Si tu déclares au moins un constructeur, puis tu essaies de créer un objet sans paramètres — tu auras une erreur de compilation :
public class Student
{
public Student(string name) { /*...*/ }
}
// quelque part dans le code
Student s = new Student(); // Erreur ! Pas de constructeur sans paramètres.
Solution : Ajouter explicitement un constructeur sans paramètres :
public Student() { /*...*/ }
Erreur n°3 : Récursion infinie — si le constructeur s'appelle lui-même
public Student()
{
// Erreur ! Il s'appelle lui-même — récursion infinie.
new Student();
}
GO TO FULL VERSION