Partager via

Constructeurs (guide de programmation C#)

Un constructeur est une méthode appelée par le runtime lorsqu’une instance d’une classe ou d’un struct est créée. Une classe ou un struct peut avoir plusieurs constructeurs qui prennent différents arguments. Les constructeurs vous permettent de vous assurer que les instances du type sont valides lors de la création. Pour obtenir plus d’informations et d’exemples, consultez Constructeurs d’instances et Utilisation de constructeurs.

Il existe plusieurs actions qui font partie de l’initialisation d’une nouvelle instance. Les actions suivantes se produisent dans l’ordre suivant :

  1. Les champs d’instance sont définis sur 0. Cette initialisation est généralement effectuée par le runtime.
  2. Les initialiseurs de champs s’exécutent. Initialiseurs de champs dans l’exécution de type le plus dérivé.
  3. Les initialiseurs de champs de type de base s’exécutent. Initialiseurs de champs commençant par la base directe via chaque type de base vers System.Object.
  4. Les constructeurs d’instances de base s’exécutent. Tous les constructeurs d’instances, en commençant par Object.Object via chaque classe de base vers la classe de base directe.
  5. Le constructeur d’instance s’exécute. Le constructeur d’instance pour le type s’exécute.
  6. les initialiseurs d’objets exécutent. Si l’expression inclut des initialiseurs d’objet, ils s’exécutent après l’exécution du constructeur d’instance. Les initialiseurs d’objets s’exécutent dans l’ordre textuel.

Les actions précédentes se produisent lorsqu’une instance est créée à l’aide de l’opérateur new. Si une nouvelle instance d’un struct est définie sur sa valeur default, tous les champs d’instance sont définis sur 0. Les éléments d’un tableau sont définis sur leur valeur par défaut 0 ou null lorsqu’un tableau est créé.

Le constructeur statique , le cas échéant, s’exécute avant l’une des actions du constructeur d’instance pour n’importe quelle instance du type. Le constructeur statique s’exécute au maximum une seule fois.

À compter de C# 14, vous pouvez déclarer des constructeurs d’instance en tant que membres partiels. Les constructeurs partiels doivent avoir à la fois une déclaration de définition et d'implémentation.

Syntaxe du constructeur

Un constructeur est une méthode portant le même nom que son type. Sa signature de méthode peut inclure un modificateur d’accès facultatif , le nom de la méthode et sa liste de paramètres ; il n’inclut pas de type de retour. L’exemple suivant montre le constructeur d’une classe nommée Person.

public class Person
{
   private string last;
   private string first;

   public Person(string lastName, string firstName)
   {
      last = lastName;
      first = firstName;
   }

   // Remaining implementation of Person class.
}

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

public class Location
{
   private string locationName;

   public Location(string name) => Name = name;

   public string Name
   {
      get => locationName;
      set => locationName = value;
   }
}

Si un type nécessite un paramètre pour créer une instance, vous pouvez utiliser un constructeur principal pour indiquer qu’un ou plusieurs paramètres sont nécessaires pour instancier le type, comme illustré dans l’exemple suivant :

public class LabelledContainer<T>(string label)
{
   public string Label { get; } = label;
   public required T Contents 
   { 
      get;
      init;
   }
}

Vous pouvez déclarer un constructeur principal sur un type partial. Une seule déclaration de constructeur principal est autorisée. En d’autres termes, une seule déclaration du partial type peut inclure les paramètres du constructeur principal.

Constructeurs statiques

Les exemples précédents montrent les constructeurs d’instances, qui initialisent un nouvel objet. Une classe ou un struct peut également déclarer 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 des champs statiques, le compilateur C# initialise les champs statiques à leur valeur par défaut, comme indiqué dans la valeurs par défaut des types C# article.

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

public class Adult : Person
{
   private static int minimumAge;

   public Adult(string lastName, string firstName) : base(lastName, firstName)
   { }

   static Adult() => minimumAge = 18;

   // Remaining implementation of Adult class.
}

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

public class Child : Person
{
   private static int maximumAge;

   public Child(string lastName, string firstName) : base(lastName, firstName)
   { }

   static Child() => maximumAge = 18;

   // Remaining implementation of Child class.
}

Pour plus d’informations et d’exemples, consultez Constructeurs Statiques.

Constructeurs partiels

À compter de C# 14, vous pouvez déclarer des constructeurs partiels dans une classe ou un struct partiel. Tout constructeur partiel doit avoir une déclaration de définition et une déclaration d’implémentation. Les signatures des constructeurs partiels déclarants et implémentant doivent correspondre conformément aux règles des membres partiels. La déclaration de définition du constructeur partiel ne peut pas utiliser l'initialiseur de constructeur : base() ou : this(). Vous devez ajouter un initialiseur de constructeur à la déclaration d’implémentation.

Voir aussi