Utilisation de constructeurs (Guide de programmation C#)

  • Article

Lorsqu’une classe ou un struct est instancié, son constructeur est appelé. 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 à l’aide de l’opérateur new. Le constructeur Taxi est appelé par l’opérateur new immédiatement après l’allocation de la mémoire pour le nouvel objet.

public class Taxi
{
    public bool IsInitialized;

    public Taxi()
    {
        IsInitialized = true;
    }
}

class TestTaxi
{
    static void Main()
    {
        Taxi t = new Taxi();
        Console.WriteLine(t.IsInitialized);
    }
}

Un constructeur qui ne prend pas de paramètres est appelé constructeur sans paramètre. Les constructeurs sans paramètre sont appelés chaque fois qu’un objet est instancié à l’aide de l’opérateur new et qu’aucun argument n’est fourni à new. C# 12 introduit les constructeurs principaux. Un constructeur principal spécifie les 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 pour les types struct ressemblent aux constructeurs de classe. Lorsqu’un type de struct est instancié avec new, un constructeur est appelé. Lorsque struct est défini sur sa valeur default, le runtime initialise toutes les mémoires dans le struct sur 0. Avant C# 10, structs ne peut pas contenir de constructeur explicite sans paramètre, car un constructeur est fourni automatiquement par le compilateur. 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 que vous soyez assuré que l’entier est initialisé :

int i = new int();
Console.WriteLine(i);

Toutefois, le code suivant provoque une erreur de compilateur, car il n’utilise pas new et il essaie d’utiliser un objet qui n’a pas été initialisé :

int i;
Console.WriteLine(i);

Les objets basés sur des structs (notamment tous les types numériques intégrés) peuvent également être initialisés ou assigné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 les constructeurs principaux. 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 ni les classes ni les structs ne sont nécessaires pour définir un constructeur sans paramètre. Par 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. Par 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 que le bloc du constructeur ne soit exécuté. 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 constructeur suivantes sont en fait les mêmes :

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 provoque l’appel de ce constructeur :

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, juste avant que des champs statiques soient accessibles, et ils sont utilisés pour initialiser des 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.

Voir aussi