Questo articolo è stato tradotto automaticamente. Per visualizzare l'articolo in inglese, selezionare la casella di controllo Inglese. È possibile anche visualizzare il testo inglese in una finestra popup posizionando il puntatore del mouse sopra il testo.
Traduzione
Inglese

Metodo Object.MemberwiseClone ()

 

Data di pubblicazione: ottobre 2016

Crea una copia superficiale dell'oggetto Object corrente.

Spazio dei nomi:   System
Assembly:  mscorlib (in mscorlib.dll)

protected object MemberwiseClone()

Valore restituito

Type: System.Object

Copia superficiale dell'oggetto Object corrente.

Il MemberwiseClone metodo crea una copia superficiale creando un nuovo oggetto e quindi copiando i campi non statici dell'oggetto corrente per il nuovo oggetto. Se un campo è un tipo di valore, viene eseguita una copia bit per bit del campo. Se un campo è un tipo di riferimento, il riferimento viene copiato ma l'oggetto cui viene fatto riferimento non; Pertanto, l'oggetto originale e il suo clone fare riferimento allo stesso oggetto.

Si consideri ad esempio un oggetto denominato X che fa riferimento agli oggetti a e B, a sua volta, oggetto references C. Una copia superficiale di X Crea nuovo oggetto X2 che fa anche riferimento a oggetti A e B. Al contrario, una copia completa di X crea un nuovo oggetto X2 che fa riferimento a nuovi oggetti A2 e B2, che sono copie di e B. B2, a sua volta, fa riferimento il nuovo oggetto C2, che è una copia di C. Nell'esempio viene illustrata la differenza tra un'operazione di copia completa e una superficiale.

Esistono diversi modi per implementare un'operazione di copia completa se eseguire l'operazione di copia dei riferimenti per il MemberwiseClone metodo non soddisfa le proprie esigenze. tra cui:

  • Chiamare un costruttore di classe dell'oggetto da copiare per creare un secondo oggetto con valori di proprietà prelevati dal primo oggetto. Ciò presuppone che i valori di un oggetto vengono definiti interamente dal costruttore di classe.

  • Chiamare il MemberwiseClone per creare una copia superficiale di un oggetto e quindi assegnare nuovi oggetti i cui valori sono uguali all'oggetto originale a qualsiasi proprietà o campi i cui valori sono i tipi di riferimento. Il DeepCopy metodo nell'esempio riportato di seguito viene illustrato questo approccio.

  • Serializzare l'oggetto per avere una profondità copiato e quindi ripristinare i dati serializzati in una variabile di un oggetto diverso.

  • Utilizzare la reflection viene utilizzata la ricorsione per eseguire l'operazione di copia completa.

Nell'esempio seguente viene illustrato il MemberwiseClone metodo. Definisce un ShallowCopy metodo che chiama il MemberwiseClone metodo per eseguire un'operazione di copia dei riferimenti in un Person oggetto. Definisce inoltre un DeepCopy metodo che esegue un'operazione di copia completa su un Person oggetto.

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.

Universal Windows Platform
Disponibile da 8
.NET Framework
Disponibile da 1.1
Libreria di classi portabile
Supportato in: piattaforme .NET portabili
Silverlight
Disponibile da 2.0
Windows Phone Silverlight
Disponibile da 7.0
Windows Phone
Disponibile da 8.1
Torna all'inizio
Mostra: