Copier le constructeur en C#

Le constructeur, qui copie les variables d'un autre objet et crée un nouvel objet, est appelé constructeur de copie. En C#, le constructeur de copie est également un constructeur paramétré. Un constructeur paramétré est un constructeur qui contient un paramètre du même type de classe. Le constructeur de copie est utile chaque fois que nous souhaitons initialiser une nouvelle instance avec les valeurs d’une instance existante. Ainsi, le constructeur Copy est un constructeur qui envoie essentiellement les valeurs d’un objet à un autre objet sans affecter les valeurs d’un objet existant.

Comment fonctionne Copy Constructor en C# ?

En C#, nous pouvons utiliser un constructeur de copie si nous voulons auditer une classe ou mémoriser les anciennes valeurs de la classe. C# ne fournit pas de constructeur de copie. Cependant, nous pouvons utiliser un constructeur de copie avec un autre constructeur.

Syntaxe

class Name {
// Parameterized Constructor
public Name(parameters)
{
// code
}
public Name(Name instance of class)   //copyconstructor
{
//code
}
}

Le nom du constructeur est le même que son nom de classe. La signature de méthode du constructeur comprend le nom de la méthode ainsi que sa liste de paramètres. Il peut y avoir n'importe quel nombre de constructeurs dans une classe. Le constructeur de copie n'est pas le seul constructeur d'une classe. Un autre constructeur est requis avec un constructeur de copie pour créer un objet. Voici un exemple qui montre comment utiliser le constructeur de copie pour une classe.

Exemple 1 : Sans constructeur de copie

Code

class Demo
{
//variables
string name;
int age;
public Demo(string name, int age) //parameterized constructor
{
this.name = name;
this.age = age;
}
public void getData()
{
Console.WriteLine("Name is:{0}", name);
Console.WriteLine("Age is:{0}", age);
}
}
class Program
{
// Main method
static void Main(string[] args)
{
Demo obj = new Demo("John",20);
obj.getData();
Console.ReadLine();
}
}

Dans l'exemple ci-dessus, il n'y a qu'un seul constructeur paramétré, qui a deux variables. getData() est utilisé pour afficher les valeurs de l'objet.

Sortie :

 

Avec le constructeur de copie

Code

class Demo
{
string name;
int age;
public Demo(string name, int age) //paramertrized constructor
{
this.name = name;
this.age = age;
}
public Demo(Demo d) //copy constructor
{
this.name = d.name;
this.age = d.age;
}
public void getData()
{
Console.WriteLine("Name is:{0}", name);
Console.WriteLine("Age is:{0}", age);
}
}
class Program
{
//main method
static void Main(string[] args){
Demo obj = new Demo("John",20);
obj.getData();
Demo obj1 = new Demo(obj); //new object
obj1.getData();
Console.ReadLine();
}
}

Dans l'exemple ci-dessus, Demo est une classe qui contient deux constructeurs. Un constructeur de copie est toujours utilisé avec un autre constructeur. Un constructeur de copie envoie les propriétés de nom et d'âge d'un objet à un autre objet. Vous trouverez ci-dessous la sortie du programme ci-dessus car les premières valeurs concernent l'objet existant, et copiez le constructeur, copiez ces valeurs et créez un nouvel objet avec les mêmes valeurs que celles de l'objet existant.

Exemple 2

Code

class pen
{
// variables
private string name;
private string color;
private int price;
//  Copy constructor
public pen(pen a)
{
name = a.name;
color = a.color;quantity = a.price;
}
// Parameterized constructor
public pen(string name, string color, int price){
this.name = name;
this.color = color;
this.quantity =price;
}
public void getPendetails()
{Console.WriteLine("Name is:{0}", name);
Console.WriteLine("color is:{0}", color);
Console.WriteLine("price is:{0}", price);
}
// Main Method
public static void Main()
{
// Create a new object.
pen p1 = new pen("Parker", "Blue", 30);
pen p2 = new pen(p1);
p2.getPendetails();
Console.ReadLine();
}}
}

Dans le programme ci-dessus, nous initialisons trois variables pour un stylo de classe qui définit les propriétés de la classe. Le constructeur de copie copie les propriétés d'un stylo d'un objet à un autre. La fonction main() initialise un objet avec les valeurs comme paramètres du constructeur paramétré. Ensuite, les valeurs sont affichées à l'aide de getPendetails(). Le nouvel objet n'affecte pas les valeurs des objets existants. Le résultat est affiché ci-dessous.

Sortie :

Exemple 3

Code

class Calculate
{
//variables
private int a;
private int b;
public Calculate(int x, int y) // parameterized constructor
{
a = x;
b = y;
}
public Calculate(Calculate cal)  //copy constructor
{
a = cal.a;
b = cal.b;
}
public int getSum()
{
return a + b;
}
}
class Sum
{
// main method
static void Main(string[] args)
{
// create a new object
Calculate c1 = new Calculate(34, 4);
Calculate c2 = new Calculate(c1);
c2.getSum();
Console.ReadLine();
}
}

Comprenons maintenant le programme ci-dessus.

La classe contient les variables a et b et deux constructeurs, c'est-à-dire un constructeur paramétré et un constructeur de copie.

Code

class Calculate
{
//variables
private int a;
private int b;
public Calculate(int x, int y) //parameterized constructor
{
a = x;
b = y;
}
public Calculate(Calculate cal) //copy constructor
{
a = cal.a;
b = cal.b;
}
public int getSum()
{
return a + b;
}
}

Le constructeur de copie envoie les valeurs de l'objet cal dans a et b.  La fonction gets() renvoie la somme de a et b. Le main() se trouve dans la classe Sum, qui initialise le c1 comme paramètres, puis copie le constructeur et envoie la valeur de l'objet c1 à l'objet c2. La somme de a et b est affichée à l'aide de getSum().

Code

class Sum
{
// main method
static void Main(string[] args)
{
Calculate c1 = new Calculate(34, 4);
Calculate c2 = new Calculate(c1);
c2.getSum();
Console.ReadLine();
}
}

Sortie :

 Règles pour le constructeur de copie en C#

• Le nom du constructeur de copie doit être le même que le nom de la classe.
• Un autre constructeur est requis avec un constructeur de copie pour copier un objet.
• Il n'y a pas de type de retour de constructeur de copie.
• Le constructeur de copie ne peut pas être final, statique et abstrait.

Conclusion

Ainsi, chaque fois que vous souhaitez copier une valeur d'objet vers d'autres objets, vous pouvez utiliser un constructeur de copie. C'est une façon d'indiquer au compilateur comment copier les valeurs d'un objet dans un autre objet. Cela se produit lorsque nous transmettons des paramètres à un objet. L'interface ICloneable est également utilisée en ajoutant une méthode Clone à votre classe, créant ainsi une copie de l'objet existant. Dans le constructeur de copie, vous pouvez spécifier un comportement personnalisé en donnant un identifiant unique ou en copiant certains champs obligatoires et pas d'autres.

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!