Constructeur en C#

Le constructeur joue un rôle très important dans la programmation orientée objet. Comprenons le rôle du constructeur en C# à l'aide des points suivants :

• Un constructeur est une méthode spéciale présente à l'intérieur d'une classe chargée d'initialiser les variables de la classe.
• Son nom est le même que le nom de la classe.
• Il est automatiquement exécuté lorsque nous créons une instance de la classe.
• Un constructeur ne renvoie aucune valeur.
• Si on ne définit pas de constructeur, un constructeur implicite est toujours fourni par la classe, qui est appelé constructeur par défaut.

Syntaxe :

public class Student()
{
//constructor
public Student()
{
//code
}
}

Ici, public Student() est une méthode qui n'a aucun type de retour, pas même void, et son nom est le même que le nom de la classe, c'est-à-dire « Student ». Ainsi, cette méthode est le constructeur de cette classe.

Quand on crée un objet de cette classe en utilisant :

Student obj = new Student();

Ensuite, le code à l'intérieur du constructeur sera exécuté.

Travail du constructeur en C#

1. Le constructeur initialise les données membres du nouvel objet. Il est invoqué par l'opérateur « nouveau » immédiatement après l'allocation de la mémoire au nouvel objet.

2. Les constructeurs explicites (constructeurs définis par l'utilisateur) peuvent être sans paramètre ou paramétrés. S'il est paramétré, alors les valeurs transmises au constructeur peuvent être attribuées aux données membres de la classe.

3. Le constructeur implicite initialise les variables de la classe avec la même valeur même si nous créons plusieurs instances de cette classe.

Exemple :

Code :

using System;
public class ConstructorDemo
{
public int num = 10;
public static void Main()
{
ConstructorDemo obj1 = new ConstructorDemo();
ConstructorDemo obj2 = new ConstructorDemo();
ConstructorDemo obj3 = new ConstructorDemo();
Console.WriteLine("obj1.num = "+obj1.num+"\nobj2.num = "+obj2.num
+"\nobj3.num = "+obj3.num);
}
}

Sortie :

Représentation picturale du programme ci-dessus :

4. Un constructeur explicite avec paramètres nous permet d'initialiser les variables de la classe avec une valeur différente à chaque fois que nous créons une instance de cette classe.

Exemple :

Code :

using System;
public class ConstructorDemo
{
public int num;
//explicit constructor
public ConstructorDemo(int num)
{
this.num = num;
}
public static void Main()
{
ConstructorDemo obj1 = new ConstructorDemo(10);
ConstructorDemo obj2 = new ConstructorDemo(20);
ConstructorDemo obj3 = new ConstructorDemo(30);
Console.WriteLine("obj1.num = "+obj1.num+"\nobj2.num = "+obj2.num
+"\nobj3.num = "+obj3.num);
}
}

Sortie :

Représentation picturale du programme ci-dessus :

Top 5 des types de constructeurs en C#

C# propose cinq types de constructeurs. Ils sont les suivants :

1. Constructeur par défaut

• Un constructeur sans aucun paramètre est appelé Constructeur par Défaut. Si nous ne le définissons pas explicitement, alors il sera implicitement fourni par le compilateur.
• Dans un tel cas, on peut appeler cela un constructeur implicite. Le constructeur par défaut ou implicite initialise toutes les données membres de la classe avec leurs valeurs par défaut, telles que tous les champs numériques à zéro et tous les champs de chaîne et d'objet à null.

Exemple :

Code :

using System;
public class DefaultConstructor
{
public int num;
public string str;
}
public class Demo
{
public static void Main()
{
DefaultConstructor obj = new DefaultConstructor();
Console.WriteLine("obj.num = "+obj.num+"\nobj.str = "+obj.str);
}
}

Sortie :

2. Constructeur paramétré

Un constructeur avec au moins un paramètre est appelé constructeur paramétré. Les paramètres au constructeur peuvent être transmis lors de la création de l'instance de la classe. Cela nous permet d'initialiser chaque instance d'une classe avec des valeurs différentes.

Exemple :

Code :

using System;
public class ParameterizedConstructor
{
public int num;
public string str;
//parameterized constructor
public ParameterizedConstructor(int num, string str)
{
this.num = num;
this.str = str;
}
}
public class Demo
{
public static void Main()
{
//passing values to constructor while creating instance
ParameterizedConstructor obj = new ParameterizedConstructor(50, "constructor");
Console.WriteLine("obj.num = "+obj.num+"\nobj.str = "+obj.str);
}
}

Sortie :

3. Copier le constructeur

C'est un constructeur paramétré qui prend l'objet de la même classe comme paramètre. Il copie la valeur de l'objet existant (qui est passée en paramètre) dans l'objet nouvellement créé instancié par le constructeur. On peut dire qu'il copie les données d'un objet vers un autre objet.

Exemple :

Code :

using System;
public class CopyConstructor
{
public int num;
public CopyConstructor(int num)
{
this.num = num;
}
//copy constructor
public CopyConstructor(CopyConstructor obj)
{
num = obj.num;
}
}
public class Demo
{
public static void Main()
{
CopyConstructor obj1 = new CopyConstructor(50);
//passing same class's object as parameter
CopyConstructor obj2 = new CopyConstructor(obj1);
Console.WriteLine("Original object:");
Console.WriteLine("obj1.num = "+obj1.num);
Console.WriteLine("\nCopied object:");
Console.WriteLine("obj2.num = "+obj2.num);
}
}

Sortie :

4. Constructeur statique

• Il peut être défini en préfixant le nom du constructeur avec un mot-clé. Il est implicitement défini par le compilateur (s'il n'est pas défini explicitement) si la classe contient une variable statique.
• C'est le premier bloc à être exécuté dans la classe et sera appelé automatiquement. Il ne sera exécuté qu'une seule fois, quel que soit le nombre d'instances de classe. Il est sans paramètre et n'accepte aucun modificateur d'accès.

Exemple :

Code :

using System;
public class StaticConstructor
{
//static constructor
static StaticConstructor()
{
Console.WriteLine("Static constructor executed");
}
public static void Display()
{
Console.WriteLine("\nDisplay method executed");
}
}
public class Demo
{
public static void Main()
{
StaticConstructor.Display();
}
}

Sortie :

5. Private Constructor

A constructor created with a private specifier is called a private constructor. We cannot create an instance of the class if it contains only a private constructor, and it does not allow other classes to derive from this class. Used in class that contains only static members.

Example:

Code:

using System;
public class PrivateConstructor
{
public static int num = 100;
//private constructor
private PrivateConstructor()
{
}
}
public class Demo
{
public static void Main()
{
//PrivateConstructor obj = new PrivateConstructor();    //Error
Console.WriteLine("num = "+PrivateConstructor.num);
}
}

Output:

Conclusion

If we define any type of constructor in a class, then there will not be any implicit constructor in the class provided by the compiler. Like methods, parameterized constructors can also be overloaded with different numbers of parameters. Constructors defined implicitly by the compiler are always public.

Recommended Article

This is a guide to Constructor in C#. Here we discuss the types of Constructor in C# and its Work along with Code Implementation and Output. You can also go through our other suggested articles to learn more –

1. Constructor in JavaScript
2. Constructor in C++
3. Copy Constructor in C#
4. Static Constructor in C#

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!