Constructeurs d'instances (Guide de programmation C#)

Les constructeurs d'instances permettent de créer et initialiser des instances. Le constructeur de classe est appelé lorsque vous créez un nouvel objet. Exemple :

class CoOrds
{
    public int x, y;

    // constructor
    public CoOrds()
    {
        x = 0;
        y = 0;
    }
}

Ce constructeur est appelé à chaque fois qu'un objet basé sur la classe CoOrds est créé. Un constructeur comme celui-ci, qui ne prend pas d'arguments, est appelé 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 des valeurs initiales pour les données membre :

// A constructor with two arguments:
public CoOrds(int x, int y)
{
    this.x = x;
    this.y = y;
}

Cela autorise la création d'objets CoOrd avec des valeurs par défaut ou initiales spécifiques, comme suit :

CoOrds p1 = new CoOrds();
CoOrds p2 = new CoOrds(5, 3);

Si une classe n'a pas de constructeur par défaut, il en est généré un automatiquement et les valeurs par défaut sont utilisées pour initialiser les champs d'objet, par exemple, int est initialisé à 0. Pour plus d'informations sur les valeurs par défaut, consultez Tableau des valeurs par défaut (Référence C#). Par conséquent, parce que le constructeur par défaut de classe CoOrds initialise toutes les données membre à zéro, il peut être supprimé entièrement sans modification du comportement de la classe. Un exemple complet d'utilisation de plusieurs constructeurs est fourni ultérieurement dans l'exemple 1 de cette rubrique, et un exemple d'un constructeur généré automatiquement est fourni dans l'exemple 2.

Les constructeurs d'instance peuvent servir à appeler les constructeurs d'instance des classes de base. Le constructeur de classe peut appeler le constructeur de la classe de base par l'intermédiaire de l'initialiseur, comme suit :

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

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 apparaît dans cette rubrique en tant qu'exemple 3.

Exemple 1

L'exemple suivant illustre une classe possédant deux constructeurs de classe, l'un sans argument et l'autre doté de deux arguments.

class CoOrds
{
    public int x, y;

    // Default constructor:
    public CoOrds()
    {
        x = 0;
        y = 0;
    }

    // A constructor with two arguments:
    public CoOrds(int x, int y)
    {
        this.x = x;
        this.y = y;
    }

    // Override the ToString method:
    public override string ToString()
    {
        return (System.String.Format("({0},{1})", x, y));
    }
}

class MainClass
{
    static void Main()
    {
        CoOrds p1 = new CoOrds();
        CoOrds p2 = new CoOrds(5, 3);

        // Display the results using the overriden ToString method:
        System.Console.WriteLine("CoOrds #1 at {0}", p1);
        System.Console.WriteLine("CoOrds #2 at {0}", p2);
    }
}

Sortie

CoOrds #1 at (0,0)

CoOrds #2 at (5,3)

Exemple 2

Dans cet exemple, la classe Person ne possède aucun constructeur, auquel cas un constructeur par défaut est fourni automatiquement, dont les champs sont initialisés sur leurs valeurs par défaut.

public class Person
{
    public int age;
    public string name;
}

class TestPerson
{
    static void Main()
    {
        Person p = new Person();

        System.Console.Write("Name: {0}, Age: {1}", p.name, p.age);
    }
}

Sortie

Name: , Age: 0

Notez que la valeur par défaut de 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 (Référence C#).

Exemple 3

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.

abstract class Shape
{
    public const double pi = System.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()
    {
        return pi * x * x;
    }
}

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

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

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

        Circle ring = new Circle(radius);
        Cylinder tube = new Cylinder(radius, height);

        System.Console.WriteLine("Area of the circle = {0:F2}", ring.Area());
        System.Console.WriteLine("Area of the cylinder = {0:F2}", tube.Area());
    }
}

Sortie

Area of the circle = 19.63

Area of the cylinder = 86.39

Pour obtenir d'autres exemples sur l'appel des constructeurs de classe de base, consultez virtual (Référence C#), override (Référence C#) et base (Référence C#).

Voir aussi

Référence

Objets, classes et structs (Guide de programmation C#)
Destructeurs (Guide de programmation C#)
static (Référence C#)

Concepts

Guide de programmation C#

Autres ressources

Constructeurs (Guide de programmation C#)