Utilisation de constructeurs (Guide de programmation C#)

Article
01/07/2009

Mise à jour : novembre 2007

Les constructeurs sont des méthodes de classe qui sont exécutées lorsqu'un objet d'un type donné est créé. Les constructeurs ont le même nom que la classe, et initialisent habituellement les données membres du nouvel objet.

Dans l'exemple suivant, une classe nommée Taxi est définie à l'aide d'un simple constructeur. Cette classe est ensuite instanciée avec un opérateur new. Le constructeur Taxi est appelé par l'opérateur new immédiatement après que la mémoire été allouée 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 par défaut. Les constructeurs par défaut 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. Pour plus d'informations, consultez Constructeurs d'instances (Guide de programmation C#).

À moins que la classe soit statique, les classes sans constructeurs se voient attribuer un constructeur public par défaut par le compilateur C# pour activer l'instanciation de classe. Pour plus d'informations, consultez Classes statiques et membres de classe statique (Guide de programmation C#).

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 (Guide de programmation C#).

Les constructeurs pour les types struct ressemblent aux constructeurs de classe, mais les structs ne peuvent pas contenir de constructeur par défaut explicite, car le compilateur en fournit automatiquement un. Ce constructeur initialise chaque champ dans le struct aux valeurs par défaut. Pour plus d'informations, consultez Tableau des valeurs par défaut (Référence C#). Toutefois, ce constructeur par défaut est appelé uniquement si le struct est instancié avec new. Par exemple, ce code utilise le constructeur par défaut pour Int32. Vous êtes par conséquent assuré que l'entier est initialisé :

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

Toutefois, le code suivant provoque une erreur Erreur du compilateur CS0165, car il n'utilise pas new, et parce qu'il essaie d'utiliser un objet qui n'a pas été initialisé :

int i;
Console.WriteLine(i);

Les objets basés sur des structs (y compris 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);

Ainsi, l'appel du constructeur par défaut pour un type valeur n'est pas obligatoire.

Les classes et les structs peuvent définir des constructeurs qui prennent des paramètres. Les constructeurs qui prennent des paramètres doivent être appelés à l'aide d'une instruction new ou d'une instruction de base. Les classes et les structs peuvent également définir plusieurs constructeurs, et aucun n'est requis pour définir un constructeur par défaut. Par exemple :

public class Employee
{
    public int salary;

    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 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 de base, ou dans le cadre d'une expression. Pour plus d'informations, consultez base (Référence C#).

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 par défaut, s'il existe, est appelé implicitement. Cela signifie que les déclarations de constructeur suivantes sont en réalité 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 par défaut, la classe dérivée doit faire un appel explicite à un constructeur de base à l'aide du mot clé 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 en tant que paramètres pour this, ou dans le cadre 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 étant publics, privés, protégés, internes ou protectedinternal. Ces modificateurs d'accès définissent comment 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 qu'un champ statique soit accessible, et ils sont généralement utilisés pour initialiser des membres de classe statique. Pour plus d'informations, consultez Constructeurs statiques.