Constructeurs d’instances (Guide de programmation C#)

  • Article

Vous déclarez un constructeur d’instance pour spécifier le code qui est exécuté lorsque vous créez une instance d’un type avec l’expression new . Pour initialiser une classe statique ou des variables statiques dans une classe non statique, vous pouvez définir un constructeur statique.

Comme le montre l’exemple suivant, vous pouvez déclarer plusieurs constructeurs d’instances dans un type :

class Coords
{
    public Coords()
        : this(0, 0)
    {  }

    public Coords(int x, int y)
    {
        X = x;
        Y = y;
    }

    public int X { get; set; }
    public int Y { get; set; }

    public override string ToString() => $"({X},{Y})";
}

class Example
{
    static void Main()
    {
        var p1 = new Coords();
        Console.WriteLine($"Coords #1 at {p1}");
        // Output: Coords #1 at (0,0)

        var p2 = new Coords(5, 3);
        Console.WriteLine($"Coords #2 at {p2}");
        // Output: Coords #2 at (5,3)
    }
}

Dans l’exemple précédent, le premier constructeur sans paramètre appelle le deuxième constructeur avec les deux arguments égaux à 0. Pour ce faire, utilisez le mot clé this.

Lorsque vous déclarez un constructeur d’instance dans une classe dérivée, vous pouvez appeler un constructeur d’une classe de base. Pour ce faire, utilisez le mot clé base, comme le montre l’exemple suivant :

abstract class Shape
{
    public const double pi = Math.PI;
    protected double x, y;

    public Shape(double x, double y)
    {
        this.x = x;
        this.y = y;
    }

    public abstract double Area();
}

class Circle : Shape
{
    public Circle(double radius)
        : base(radius, 0)
    {  }

    public override double Area() => pi * x * x;
}

class Cylinder : Circle
{
    public Cylinder(double radius, double height)
        : base(radius)
    {
        y = height;
    }

    public override double Area() => (2 * base.Area()) + (2 * pi * x * y);
}

class Example
{
    static void Main()
    {
        double radius = 2.5;
        double height = 3.0;

        var ring = new Circle(radius);
        Console.WriteLine($"Area of the circle = {ring.Area():F2}");
        // Output: Area of the circle = 19.63
        
        var tube = new Cylinder(radius, height);
        Console.WriteLine($"Area of the cylinder = {tube.Area():F2}");
        // Output: Area of the cylinder = 86.39
    }
}

Constructeurs sans paramètre

Si une classe n’a aucun constructeur d’instance explicite, C# fournit un constructeur sans paramètre que vous pouvez utiliser pour instancier une instance de cette classe, comme le montre l’exemple suivant :

public class Person
{
    public int age;
    public string name = "unknown";
}

class Example
{
    static void Main()
    {
        var person = new Person();
        Console.WriteLine($"Name: {person.name}, Age: {person.age}");
        // Output:  Name: unknown, Age: 0
    }
}

Ce constructeur initialise les champs et propriétés de l’instance en fonction des initialiseurs correspondants. Si un champ ou une propriété n’a pas d’initialiseur, sa valeur est définie sur la valeur par défaut du type du champ ou de la propriété. Si vous déclarez au moins un constructeur d’instance dans une classe, C# ne fournit pas de constructeur sans paramètre.

Un type de structure fournit toujours un constructeur sans paramètre comme suit :

  • Dans C# 9.0 et antérieur, il s’agit d’un constructeur sans paramètre implicite qui produit la valeur par défaut d’un type.
  • Dans C# 10 et ultérieur, il s’agit d’un constructeur sans paramètre implicite qui produit la valeur par défaut d’un type ou d’un constructeur sans paramètre déclaré explicitement. Pour plus d’informations, consultez la section Initialisation de struct et valeurs par défaut de l’article Types de structure.

Voir aussi