Cet article a fait l’objet d’une traduction automatique. Pour afficher l’article en anglais, activez la case d’option Anglais. Vous pouvez également afficher le texte anglais dans une fenêtre contextuelle en faisant glisser le pointeur de la souris sur le texte traduit.
Traduction
Anglais

Object.MemberwiseClone méthode ()

 

Date de publication : novembre 2016

Crée une copie superficielle du Object actuel.

Espace de noms:   System
Assembly:  mscorlib (dans mscorlib.dll)

protected object MemberwiseClone()

Valeur de retour

Type: System.Object

Copie superficielle du Object actuel.

Le MemberwiseClone méthode crée une copie superficielle en créant un nouvel objet, puis en copiant les champs non statiques de l’objet actuel vers le nouvel objet. Si un champ est un type valeur, une copie bit par bit du champ est effectuée. Si un champ est un type référence, la référence est copiée, mais l’objet référencé ne l’est pas. Par conséquent, l’objet d’origine et son clone font référence au même objet.

Par exemple, considérez un objet appelé X qui référence des objets A et B, à son tour. Une copie superficielle de X crée l’objet X2 qui référence également des objets A et B. En revanche, une copie complète de X crée un nouvel objet X2 qui fait référence à nouveaux objets A2 et B2, qui sont des copies de A et B. B2 référence à son tour, le nouvel objet C2, qui est une copie de C. L’exemple illustre la différence entre un superficielle et une opération de copie complète.

Il existe plusieurs façons d’implémenter une opération de copie complète si l’opération de copie superficielle exécutée par le MemberwiseClone (méthode) ne répond pas à vos besoins. Notamment :

  • Appeler un constructeur de classe de l’objet à copier pour créer un second objet avec les valeurs de propriété extraites du premier objet. Cela suppose que les valeurs d’un objet sont entièrement définis par son constructeur de classe.

  • Appelez le MemberwiseClone méthode pour créer une copie superficielle d’un objet, puis assignez de nouveaux objets dont les valeurs sont les mêmes que l’objet d’origine pour les propriétés ou les champs dont les valeurs sont des types référence. Le DeepCopy méthode dans l’exemple illustre cette approche.

  • Sérialiser l’objet de manière complète copié et restaurer les données sérialisées à une variable d’objet différent.

  • Utilisez la réflexion avec la récursivité pour effectuer l’opération de copie complète.

L’exemple suivant illustre la MemberwiseClone méthode. Il définit un ShallowCopy méthode qui appelle le MemberwiseClone méthode pour effectuer une opération de copie superficielle sur un Person objet. Il définit également un DeepCopy méthode qui effectue une opération de copie complète sur un Person objet.

using System;

public class IdInfo
{
    public int IdNumber;

    public IdInfo(int IdNumber)
    {
        this.IdNumber = IdNumber;
    }
}

public class Person 
{
    public int Age;
    public string Name;
    public IdInfo IdInfo;

    public Person ShallowCopy()
    {
       return (Person) this.MemberwiseClone();
    }

    public Person DeepCopy()
    {
       Person other = (Person) this.MemberwiseClone();
       other.IdInfo = new IdInfo(IdInfo.IdNumber);
       other.Name = String.Copy(Name);
       return other;
    }
}

public class Example
{
    public static void Main()
    {
        // Create an instance of Person and assign values to its fields.
        Person p1 = new Person();
        p1.Age = 42;
        p1.Name = "Sam";
        p1.IdInfo = new IdInfo(6565);

        // Perform a shallow copy of p1 and assign it to p2.
        Person p2 = p1.ShallowCopy();

        // Display values of p1, p2
        Console.WriteLine("Original values of p1 and p2:");
        Console.WriteLine("   p1 instance values: ");
        DisplayValues(p1);
        Console.WriteLine("   p2 instance values:");
        DisplayValues(p2);

        // Change the value of p1 properties and display the values of p1 and p2.
        p1.Age = 32;
        p1.Name = "Frank";
        p1.IdInfo.IdNumber = 7878;
        Console.WriteLine("\nValues of p1 and p2 after changes to p1:");
        Console.WriteLine("   p1 instance values: ");
        DisplayValues(p1);
        Console.WriteLine("   p2 instance values:");
        DisplayValues(p2);

        // Make a deep copy of p1 and assign it to p3.
        Person p3 = p1.DeepCopy();
        // Change the members of the p1 class to new values to show the deep copy.
        p1.Name = "George";
        p1.Age = 39;
        p1.IdInfo.IdNumber = 8641;
        Console.WriteLine("\nValues of p1 and p3 after changes to p1:");
        Console.WriteLine("   p1 instance values: ");
        DisplayValues(p1);
        Console.WriteLine("   p3 instance values:");
        DisplayValues(p3);
    }

    public static void DisplayValues(Person p)
    {
        Console.WriteLine("      Name: {0:s}, Age: {1:d}", p.Name, p.Age);
        Console.WriteLine("      Value: {0:d}", p.IdInfo.IdNumber);
    }
}
// The example displays the following output:
//       Original values of p1 and p2:
//          p1 instance values:
//             Name: Sam, Age: 42
//             Value: 6565
//          p2 instance values:
//             Name: Sam, Age: 42
//             Value: 6565
//       
//       Values of p1 and p2 after changes to p1:
//          p1 instance values:
//             Name: Frank, Age: 32
//             Value: 7878
//          p2 instance values:
//             Name: Sam, Age: 42
//             Value: 7878
//       
//       Values of p1 and p3 after changes to p1:
//          p1 instance values:
//             Name: George, Age: 39
//             Value: 8641
//          p3 instance values:
//             Name: Frank, Age: 32
//             Value: 7878

In this example, the Person.IdInfo property returns an IdInfo object. As the output from the example shows, when a Person object is cloned by calling the M:System.Object.MemberwiseClone method, the cloned Person object is an independent copy of the original object, except that they share the same Person.IdInfo object reference. As a result, modifying the clone's Person.IdInfo property changes the original object's Person.IdInfo property. On the other hand, when a deep copy operation is performed, the cloned Person object, including its Person.IdInfo property, can be modified without affecting the original object.

Plateforme Windows universelle
Disponible depuis 8
.NET Framework
Disponible depuis 1.1
Bibliothèque de classes portable
Pris en charge dans : plateformes .NET portables
Silverlight
Disponible depuis 2.0
Silverlight pour Windows Phone
Disponible depuis 7.0
Windows Phone
Disponible depuis 8.1
Retour au début
Afficher: