Utiliser des constructeurs (guide de programmation C#)
Lorsqu’une classe ou struct est instanciée, le runtime appelle son constructeur. Les constructeurs portent le même nom que la classe ou le struct, et ils initialisent généralement les membres de données du nouvel objet.
Dans l’exemple suivant, une classe nommée Taxi est définie en utilisant un constructeur simple. Cette classe est ensuite instanciée avec l’opérateur new. Le runtime appelle le constructeur Taxi immédiatement après l’allocation de la mémoire pour le nouvel objet.
public class Taxi
{
private string taxiTag;
public Taxi(string tag) => taxiTag = tag;
public override string ToString() => $"Taxi: {taxiTag}";
}
class TestTaxi
{
static void Main()
{
Taxi t = new Taxi("Tag1345");
Console.WriteLine(t);
}
}
Un constructeur qui ne prend pas de paramètres est appelé constructeur sans paramètre. Le runtime appelle le constructeur sans paramètre lorsqu’un objet est instancié à l’aide de l’opérateur new et qu’aucun argument n’est fourni à new. C# 12 a lancé les constructeurs primaires. Un constructeur primaire spécifie des paramètres qui doivent être fournis pour initialiser un nouvel objet. Pour plus d’informations, consultez Constructeurs d’instances.
À moins d’être statiques, les classes sans constructeur se voient attribuer un constructeur public sans paramètre par le compilateur C#, afin d’activer l’instanciation de classe. Pour plus d’informations, consultez la page Classes statiques et membres de classes statiques.
Vous pouvez empêcher qu’une classe soit instanciée en rendant le constructeur privé, comme suit :
class NLog
{
// Private Constructor:
private NLog() { }
public static double e = Math.E; //2.71828...
}
Pour plus d’informations, consultez Constructeurs privés.
Les constructeurs de types struct et sont similaires aux constructeurs de classes. Lorsqu’un type de struct est instancié avec new, le runtime appelle un constructeur. Lorsqu’un struct est paramétré sur sa valeur default, le runtime initialise toute la mémoire dans le struct à 0. Si vous déclarez des initialiseurs de champ dans un type struct, vous devez fournir un constructeur sans paramètre. Pour plus d’informations, consultez la section Initialisation de struct et valeurs par défaut de l’article Types de structure .
Le code suivant utilise le constructeur sans paramètre pour Int32, afin de garantir que l’entier soit initialisé :
int i = new int();
Console.WriteLine(i);
Toutefois, le code suivant provoque une erreur du compilateur, car elle n’utilise pas new, et parce qu’elle tente d’utiliser un objet qui n’est pas initialisé :
int i;
Console.WriteLine(i);
Par ailleurs, certains types struct (y compris tous les types numériques intégrés) peuvent être initialisés ou affectés, puis utilisés comme dans l’exemple suivant :
int a = 44; // Initialize the value type...
int b;
b = 33; // Or assign it before using it.
Console.WriteLine("{0}, {1}", a, b);
Les classes et les structs peuvent définir des constructeurs qui prennent des paramètres, y compris des constructeurs primaires. Les constructeurs qui prennent des paramètres doivent être appelés à l’aide d’une instruction new ou d’une instruction base. Les classes et les structs peuvent également définir plusieurs constructeurs, et aucune d’entre elles n’est obligée de définir un constructeur sans paramètre. Exemple :
public class Employee
{
public int Salary;
public Employee() { }
public Employee(int annualSalary) => Salary = annualSalary;
public Employee(int weeklySalary, int numberOfWeeks) => Salary = weeklySalary * numberOfWeeks;
}
Cette classe peut être créée à l’aide de l’une ou l’autre des instructions suivantes :
Employee e1 = new Employee(30000);
Employee e2 = new Employee(500, 52);
Un constructeur peut utiliser le mot clé base pour appeler le constructeur d’une classe de base. Exemple :
public class Manager : Employee
{
public Manager(int annualSalary)
: base(annualSalary)
{
//Add further instructions here.
}
}
Dans cet exemple, le constructeur de la classe de base est appelé avant l’exécution du bloc du constructeur. Le mot clé base peut être utilisé avec ou sans paramètres. Tous les paramètres du constructeur peuvent être utilisés comme paramètres pour base ou comme partie d’une expression. Pour plus d’informations, consultez base.
Dans une classe dérivée, si un constructeur de classe de base n’est pas appelé explicitement à l’aide du mot clé base, le constructeur sans paramètre, s’il existe, est appelé implicitement. Les déclarations de constructeurs suivantes sont en réalité équivalentes :
public Manager(int initialData)
{
//Add further instructions here.
}
public Manager(int initialData)
: base()
{
//Add further instructions here.
}
Si une classe de base n’offre pas de constructeur sans paramètre, la classe dérivée doit faire un appel explicite à un constructeur de base à l’aide de base.
Un constructeur peut appeler un autre constructeur dans le même objet à l’aide du mot clé this. Comme base, this peut être utilisé avec ou sans paramètres, et tous les paramètres dans le constructeur sont disponibles comme paramètres pour this ou comme partie d’une expression. Par exemple, le deuxième constructeur de l’exemple précédent peut être récrit à l’aide de this :
public Employee(int weeklySalary, int numberOfWeeks)
: this(weeklySalary * numberOfWeeks)
{
}
L’utilisation du mot clé this dans l’exemple précédent entraîne l’appel du constructeur suivant :
public Employee(int annualSalary) => Salary = annualSalary;
Les constructeurs peuvent être marqués comme public, private, protected, internal, protected internal ou private protected. Ces modificateurs d’accès définissent la façon dont les utilisateurs de la classe peuvent construire la classe. Pour plus d’informations, consultez Modificateurs d’accès.
Un constructeur peut être déclaré statique à l’aide du mot clé static. Les constructeurs statiques sont appelés automatiquement, avant d’accéder à des champs statiques et sont utilisés pour initialiser les membres de classe statique. Pour plus d’informations, consultez Constructeurs statiques.
Spécification du langage C#
Pour plus d’informations, consultez Constructeurs d’instances et Constructeurs statiques dans la spécification du langage C#. La spécification du langage est la source de référence pour la syntaxe C# et son utilisation.
