Nous voici dans une partie interessante. Au début, quand j'ai appris le concept des constructeurs, je ne comprenais pas leur intêret. Maintenant, je ne réflechis même plus quand je les crée. A chaque fois que vous développerez une classe, vous utiliserez les constructeurs car c'est extrêment utile. Voyons cela à l'aide d'un exemple. Nous allons pour cela reprendre une classe déjà développée dans un des cours précédent. Créez donc un nouveau projet appelé Class Test. Ajoutez une classe nommée Etudiant.cs dans laquelle vous placerez ce code :

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Class_Test
{
	class Etudiant
	{
		public string nom;
		public string prenom;
		public int age;

		public void setNom(string nouveauNom)
		{
			nom = nouveauNom;
		}

		public void setPrenom(string nouveauPrenom)
		{
			prenom = nouveauPrenom;
		}

		public void setAge(int nouvelAge)
		{
			age = nouvelAge;
		}

		public string resume()
		{
			return "Nom : " + nom + "
Prénom : " + prenom + "
Age : " + age;
		}
	}
}

Dans le cours où nous avions développé cette classe, nous avions tapé ce code pour l'utiliser :

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Class_Test
{
	class Program
	{
		static void Main(string[] args)
		{
			Etudiant etudiant = new Etudiant();

			etudiant.setNom("Adams");
			etudiant.setPrenom("Bryan");
			etudiant.setAge(21);

			Console.WriteLine(etudiant.resume());
			Console.Read();
		}
	}
}

Ce code fonctionne très bien mais il est un peu lourd. Effectivement, devoir appeler à chaque fois une fonction juste pour initialiser une propriété de l'objet, c'est assez lourd. La première solution pour palier à ce problème est de donner une valeur par défaut aux propriétés. Effectivement, vous auriez pu déclarer vos propriétés de cette manière :

public string nom = "Adams";
public string prenom = "Bryan";
public int age = 21; 

Dans ce cas, quand vous créerez un objet sans appeler la fonction setNom, setPrenom et setAge, les propriétés de cet objet seront toujours initialisées sur Bryan Adams de 21 ans. Il faudra alors appeler les fonctions setAge, setNom et setPrenom pour modifier ces propriétés. C'est une bonne solution, mais imaginez que vous vouliez créez un étudiant appelé Freddie Mercury de 43 ans. Le problème reste le même, vous êtes obligé d'appeler les 3 fonctions pour créer cet objet avec les propriétés voulues. C'est pour palier à ce problème que les constructeurs existent. En fait, les constructeurs vont être appelés à la création de l'objet. C'est une fonction qui recevra des paramètres qui permettront d'initialiser les propriétés de l'objet. En fait, si vous voulez créer un objet de la classe Etudiant vous devrez faire ainsi :

Etudiant obj = new Etudiant(); 

Comme vous le voyez, nous devons utiliser le mot-clé new pour créer un nouvel objet. Nous utilisons ensuite le nom de la classe suivi de parenthèses. Si vous vous rappelez, les parenthèses sont le signe d'une fonction. Effectivement, créer un objet fait appel à une fonction spéciale de la classe. Si vous ne la déclarez pas, elle sera implicitement implentée par le compilateur, mais vous pouvez l'implémenter vous-même. Avant de passer à l'exemple, voilà la déclaration d'un constructeur de classe :

public [static] nom(type1 arg1, ...) {

}

La première particularité de cette fonction est qu'elle ne possède pas de type. Effectivement, un constructeur ne peut JAMAIS renvoyer de valeur. Il est donc inutile de spécifier le type de valeur renvoyée par cette fonction. La deuxième particularité est que le nom de cette fonction doit OBLIGATOIREMENT être le même que le nom de la classe. Vous pouvez implémenter autant de constructeur que vous voulez. Nous verrons ça plus tard. Avant d'implémenter un constructeur, il faut se demander s'il sera utile. Dans notre cas, il serait inutile de créer un constructeur sans paramètre. Effectivement, un constructeur utile serait un constructeur à 3 paramètres. Ce constructeur prendrait le nom, le prénom et l'age de l'étudiant à créer. Ainsi, une fois ces paramètres reçus, il initialisera les propriétés de l'objet lors de sa création, mais voyons cela. Revenez dans le fichier Etudiant.cs et commencez par supprimer les fonctions existantes. Une fois cela fait, modifiez le nom des propriétés de la classe en mettant la première lettre de leur nom en majuscule. Tapez ensuite ce construteur en dessous de la déclaration des propriétés de la classe :

public Etudiant(string nom, string prenom, int age)
{
	this.Nom = nom;
	this.Prenom = prenom;
	this.Age = age;
}

Comme vous le voyez, ce constructeur reçoit 3 paramètres : nom, prenom et age. Le corps de ce constructeur sert simplement à initialiser les propriétés de l'objet à l'aide des paramètres passés à ce constructeur. Comme vous le voyez, nous accédons aux propriétés de l'objet grâce au mot-clé this. Ce n'est pas indispensable, vous n'étiez pas obligé de l'utiliser, mais bon, je trouve ça plus propre. Enfin, vous devrez également modifier la fonction resume. Il vous faudra simplement modifier le nom des 3 propriétés utilisées par leur nouveau nom. Revenez maintenant dans Program.cs et tapez :

Etudiant etudiant = new Etudiant("Adams", "Bryan", 21);
Console.WriteLine(etudiant.resume());

Cette fois, nous créons cet objet en faisant passer des paramètres au constructeur, comme vous voyez, nous tapons bêtement le nom, le prénom et l'age de l'étudiant à créer, mais nous les faisons passer dans le constructeur. Du coup, le constructeur créé précédemment va être appelé avec ces paramètres et les propriétés de l'objet vont donc être initialisées par les valeurs passées en paramètres. Si vous exécutez le programme, vous verrez qu'il fonctionne à merveille. Une chose que vous devez savoir c'est que, si vous ne déclarez aucun constructeur à votre classe, un constructeur par défaut (sans paramètre) est implémenté implicitement par le compilateur. Par contre, si vous déclarez un constructeur avec paramètre dans votre classe, le compilateur n'implémentera pas de lui-même un constructeur sans paramètre. Donc, dans le code précédent, si vous tapez :

Etudiant etudiant = new Etudiant(); 

Le compilateur vous affichera une erreur vous disant qu'aucun constructeur sans paramètre n'est déclaré. Si vous le désirez, vous pouvez déclarer un constructeur sans paramètre et ne rien mettre dans le corps de ce constructeur, c'est à vous de voir de quel constructeur vous avez besoin. Une nouveauté en C# est la possibilité de faire des constructeurs statiques. Je n'ai jamais eu besoin d'utiliser ces constructeurs, mais vous pouvez en créer. La déclaration d'un constructeur statique est la suivante :

static nom() {

} 

Un constructeur statique ne possède ni modificateurs d'accès, ni arguments. Vous ne pouvez pas non plus appeler vous-même un constructeur statique. Effectivement, c'est le runtime .NET qui s'en chargera. Ce type de constructeur sert essentiellement à initialiser des variables statiques. En effet, un constructeur ne peut accéder qu'à des propriétés statiques. La surchage des constructeurs est également possible. Cela veut dire que vous pouvez très bien déclarer plusieurs constructeurs dans vos classes. Vous devez juste vous assurer que la signature du constructeur sera différente. En effet, il faut juste que les paramètres attendus par les différentes constructeurs soient différents. Vous ne pouvez donc pas déclarer deux constructeurs attendant tous les deux 2 chaînes de caractères et un entier. Vous pouvez par contre déclarer un constructeur attendant deux string et un int et un autre constructeur attendant une string et deux int. Vous pouvez également faire appel à un constructeur grâce à un autre. Effectivement, imaginez que dans la classe Etudiant vous proprosiez un constructeur attendant 2 chaînes de caractères permettant d'initialiser le nom et le prénom de l'étudiant. Si ce constructeur est appelé, l'age de l'étudiant sera par défaut de 20 ans. Pour l'instant, vous feriez un constructeur de ce type :

public Etudiant(string nom, string prenom)
{
	this.Nom = nom;
	this.Prenom = prenom;
	this.Age = 20;
} 

Cela fonctionnerait très bien mais c'est un peu inutile. Dans le sens qu'il existe déjà un constructeur permettant d'initialiser les 3 propriétés de cet objet, il serait pratique de l'utiliser à la place de retaper l'initialisation des 3 propriétés. Pour cela, il faut utiliser la liste d'initialisation des constructeurs. Voici comment se présente la déclaration d'un constructeur avec liste d'initialisation :

public nom(...) : liste {

}

La liste d'initialisation permet d'initialiser des propriétés ou autres avant toutes autres. Généralement on s'en sert pour appeler un autre constructeur depuis le constructeur actuel. Pour appeler un constructeur, il suffit d'utiliser la fonction this. Effectivement, bien que this est la référence à l'objet, c'est également une manière d'appeler un constructeur de la classe. Voici comment vous feriez pour déclarer le constructeur précédent en utilisant l'appel à un autre constructeur :

public Etudiant(string nom, string prenom) : this (nom, prenom, 20)
{ } 

Comme vous le voyez, nous appelons un constructeur depuis un autre constructeur grâce à la liste d'initialisation. Le compilateur saura directement quel constructeur est appelé grâce au type et au nombre de paramètres attendus. La façon dont l'appel est fait est très simple. Nous faisons passer au premier constructeur les paramètres du constructeur appelé. Comme age n'est pas déclaré comme paramètre du constructeur, nous passons la valeur par défaut.