Constructeurs d'instances (Guide de programmation C#)

Article
08/10/2011

Les constructeurs d'instance sont utilisés pour créer et initialiser toutes les variables de membres d'instance lorsque vous utilisez l'expression new pour créer un objet d'une classe. Pour initialiser une classe static, ou des variables static dans une classe non static, vous devez définir un constructeur static. Pour plus d'informations, consultez Constructeurs statiques (Guide de programmation C#).

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

class CoOrds
{
    public int x, y;

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

Notes

Dans un souci de clarté, cette classe contient des champs publics. L'utilisation de champs publics n'est pas une pratique de programmation recommandée, car elle octroie à n'importe quelle méthode n'importe où dans un programme un accès sans restriction ni vérification aux mécanismes internes d'un objet. Les membres Data doivent généralement être privés et doivent être accessibles uniquement par le biais de méthodes de classe et de propriétés.

Ce constructeur d'instance 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 :

// tcA 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, un constructeur par défaut est généré 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;
    }

    // tcA 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 (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:
        Console.WriteLine("CoOrds #1 at {0}", p1);
        Console.WriteLine("CoOrds #2 at {0}", p2);
        Console.ReadKey();
    }
}
/* Output:
 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 person = new Person();

        Console.WriteLine("Name: {0}, Age: {1}", person.name, person.age);
        // Keep the console window open in debug mode.
        Console.WriteLine("Press any key to exit.");
        Console.ReadKey();
    }
}
// Output:  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 = 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);

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

        // Keep the console window open in debug mode.
        Console.WriteLine("Press any key to exit.");
        Console.ReadKey();
    }
}
/* Output:
    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#).