Introduction

Chaque fois qu'une classe ou un struct est créé, son constructeur est appelé. Une classe ou un struct peut avoir plusieurs constructeurs qui prennent des arguments différents. Les constructeurs permettent au programmeur de définir des valeurs par défaut, de limiter l'instanciation et d'écrire un code flexible et facile à lire. Pour obtenir plus d'informations et d'exemples, consultez Utilisation de constructeurs et Constructeurs d'instances.

Constructeurs par défaut

Si vous ne fournissez pas de constructeur pour votre classe, C# en crée un par défaut qui instancie l'objet et affecte aux variables membres les valeurs par défaut listées dans le Tableau des valeurs par défaut. Si vous ne fournissez pas de constructeur pour votre struct, C# s'appuie sur un constructeur par défaut implicite pour initialiser automatiquement chaque champ d'un type valeur à sa valeur par défaut listée dans le Tableau des valeurs par défaut. Pour obtenir plus d'informations et d'exemples, consultez Constructeurs d'instances.

Syntaxe du constructeur

Un constructeur est une méthode dont le nom est le même que celui de son type. Sa signature de méthode inclut uniquement le nom de la méthode et sa liste de paramètres; elle n'inclut pas de type de retour. L'exemple suivant affiche le constructeur d'une classe nommée Person.

Si un constructeur peut être implémenté comme une seule instruction, vous pouvez utiliser une définition de corps d'expression. L'exemple suivant définit une classe Location dont le constructeur a un seul paramètre de chaîne nommé name. La définition de corps d'expression assigne l'argument au champ locationName.

Constructeurs statiques

Les exemples précédents ont tous montré des constructeurs d'instances qui permettent de créer un objet. Une classe ou un struct peut également avoir un constructeur statique qui initialise les membres statiques du type. Les constructeurs statiques sont sans paramètre. Si vous ne fournissez pas de constructeur statique pour initialiser les champs statiques, le compilateur C# fournit un constructeur statique par défaut qui initialise les champs statiques à leur valeur par défaut listée dans le Tableau des valeurs par défaut.

L'exemple suivant utilise un constructeur statique pour initialiser un champ statique.

Vous pouvez également définir un constructeur statique avec une définition de corps d'expression, comme l'illustre l'exemple suivant.

Utilisation de constructeurs

Quand une classe ou un struct est créé, 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.

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.

à 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.

Vous pouvez empêcher qu'une classe soit instanciée en rendant le constructeur privé, comme suit :

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 du struct aux valeurs par défaut. Pour plus d'informations, consultez Tableau des valeurs par défaut. 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é :

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é :

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 :

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

Les classes et les structs peuvent tous les deux 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 base. Les classes et les structs peuvent également définir plusieurs constructeurs, et ni l'un ni l'autre n'est nécessaire pour définir un constructeur par défaut. Par exemple :

Cette classe peut être créée à l'aide de l'une ou l'autre des instructions suivantes :

Un constructeur peut utiliser le mot clé base pour appeler le constructeur d'une classe de base. Par exemple :

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 par défaut, s'il existe, est appelé implicitement. Cela signifie que les déclarations de constructeur suivantes sont en fait les mêmes :


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 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 :

L'utilisation du mot clé this dans l'exemple précédent provoque l'appel de ce constructeur :

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 la page 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 généralement utilisés pour initialiser des membres de classe statique.

Constructeurs d'instances

Les constructeurs d'instances sont utilisés pour créer et initialiser toutes les variables membres d'instance quand vous utilisez l'expression new pour créer un objet d'une classe. Pour initialiser une classe statique ou des variables statiques dans une classe non statique, vous devez définir un constructeur statique. Pour plus d'informations, consultez Constructeurs statiques.

L'exemple suivant présente un constructeur d'instance :



Ce constructeur d'instance est appelé chaque fois qu'un objet basé sur la classe Coords est créé. Un constructeur comme celui-ci, qui n'accepte aucun argument, est un constructeur par défaut. Toutefois, il est souvent utile de fournir des constructeurs supplémentaires. Par exemple, nous pouvons ajouter un constructeur à la classe Coords qui nous permet de spécifier les valeurs initiales pour les données membres :

Cela permet de créer des objets CoOrd avec des valeurs par défaut ou initiales spécifiques, comme suit :

Si une classe n'a pas de constructeur, un constructeur par défaut est généré automatiquement et les valeurs par défaut sont utilisées pour initialiser les champs objet. Par exemple, int est initialisé à 0. Pour plus d'informations sur les valeurs par défaut, consultez Tableau des valeurs par défaut. Par conséquent, comme le constructeur par défaut de la classe Coords initialise toutes les données membres à zéro, il peut être supprimé entièrement sans modification du fonctionnement de la classe. Un exemple complet d'utilisation de plusieurs constructeurs est fourni dans l'exemple 1, plus loin dans cette rubrique, et un exemple d'un constructeur généré automatiquement est fourni dans l'exemple 2. Les constructeurs d'instances peuvent également servir à appeler les constructeurs d'instances des classes de base. Le constructeur de classe peut appeler le constructeur de la classe de base via l'initialiseur, comme suit :

Dans cet exemple, la classe Circle passe des valeurs représentant le rayon et la hauteur au constructeur fourni par Shape duquel Circle est dérivé. Un exemple complet d'utilisation de Shape et Circle s'affiche dans cette rubrique en tant qu'exemple 3.

Exemple

L'exemple suivant illustre une classe avec deux constructeurs de classe, l'un sans argument et l'autre avec deux arguments.

Dans cet exemple, la classe Person n'a aucun constructeur, auquel cas un constructeur par défaut est fourni automatiquement et les champs sont initialisés à leurs valeurs par défaut.

Notez que la valeur par défaut d'age est 0 et que celle de name est null. Pour plus d'informations sur les valeurs par défaut, consultez Tableau des valeurs par défaut.

L'exemple suivant illustre l'utilisation de l'initialiseur de classe de base. La classe Circle est dérivée de la classe générale Shape et la classe Cylinder est dérivée de la classe Circle. Le constructeur de chaque classe dérivée utilise son initialiseur de classe de base.

Pour obtenir d'autres exemples sur l'appel des constructeurs de classe de base, consultez virtual, override et base.

Constructeurs privés

Un constructeur privé est un constructeur d'instance spécial. Il est généralement utilisé dans les classes qui contiennent uniquement des membres statiques. Si une classe a un ou plusieurs constructeurs privés, mais n'a aucun constructeur public, les autres classes (à l'exception des classes imbriquées) ne peuvent pas créer d'instances de cette classe, par exemple :

La déclaration du constructeur vide empêche la génération automatique d'un constructeur par défaut. Notez que si vous n'utilisez pas de modificateur d'accès avec le constructeur, le constructeur est toujours privé par défaut. En règle générale, le modificateur private est explicitement utilisé pour spécifier que la classe ne peut pas être instanciée.

Les constructeurs privés servent à empêcher la création d'instances d'une classe quand il n'y a pas de champs ou de méthodes d'instance (par exemple, la classe Math) ou quand une méthode est appelée pour obtenir une instance d'une classe. Si toutes les méthodes dans la classe sont statiques, définissez la classe entière comme statique. Pour plus d'informations, consultez Classes statiques et membres de classe statique.

Exemple

L'exemple suivant montre une classe qui utilise un constructeur privé.

Notez que si vous décommentez l'instruction suivante dans l'exemple, une erreur est générée, car le constructeur a un niveau de protection qui le rend inaccessible :

Constructeurs statiques

Un constructeur statique est utilisé pour initialiser des données statiques ou pour effectuer une action particulière qui ne doit être effectuée qu'une seule fois. Il est automatiquement appelé avant la création de la première instance ou le référencement d'un membre statique.

Les constructeurs statiques ont les propriétés suivantes :

• Un constructeur statique n'accepte pas de modificateur d'accès et n'a pas de paramètre.
• Un constructeur statique est automatiquement appelé pour initialiser la classe avant la création de la première instance ou le référencement d'un membre statique.
• Un constructeur statique ne peut pas être appelé directement.
• L'utilisateur n'a aucun contrôle sur le moment d'exécution du constructeur statique dans le programme.
• Généralement, on utilise des constructeurs statiques quand la classe utilise un fichier journal et que le constructeur sert à écrire des entrées dans ce fichier.
• Les constructeurs statiques sont également utiles pour la création de classes wrapper pour du code non managé, quand le constructeur peut appeler la méthode LoadLibrary.
• Si un constructeur statique lève une exception, le runtime ne l'appelle pas une deuxième fois et le type reste non initialisé pour la durée de vie du domaine d'application dans lequel votre programme s'exécute.

Exemple

Dans cet exemple, la classe Bus possède un constructeur statique. Quand la première instance de Bus est créée (bus1), le constructeur statique est appelé pour initialiser la classe. L'exemple de sortie vérifie que le constructeur statique s'exécute une seule fois, même si deux instances de Bus sont créées, et qu'il s'exécute avant le constructeur d'instance.

Écrire un constructeur de copie

Dans l'exemple suivant, la Personclasse définit un constructeur de copie qui prend comme argument une instance de Person. Les valeurs des propriétés de l'argument sont assignées aux propriétés de la nouvelle instance de Person. Le code contient un autre constructeur de copie qui envoie les propriétés Name et Age de l'instance que vous voulez copier au constructeur d'instance de la classe.