Object.MemberwiseClone (Método)

El método MemberwiseClone crea una copia superficial mediante la creación de un nuevo objeto y la copia posterior de los campos no estáticos del objeto actual en el objeto nuevo. Si un campo es de un tipo de valor, se realiza una copia bit a bit de él. Si un campo es un tipo de referencia, se copia la referencia pero no el objeto al que se hace referencia; por consiguiente, el objeto original y su copia hacen referencia al mismo objeto.

Por ejemplo, considere un objeto denominado X que hace referencia a los objetos A y B. El objeto B, a su vez, hace referencia al objeto C. Una copia superficial de X crea nuevo objeto X2, que también hace referencia a los objetos A y B. En contraste, una copia en profundidad de X crea un nuevo objeto X2 que hace referencia a los nuevos objetos A2 y B2, de los que son las copias A y B. B2, a su vez, hace referencia al nuevo objeto C2, que es una copia C. En el ejemplo se muestra la diferencia entre una operación de copia superficial y de copia en profundidad.

Hay numerosas maneras de implementar una operación de la copia en profundidad si la operación de copia superficial realizada por el método MemberwiseClone no satisface sus necesidades. Se incluyen las siguientes:

• Llame a un constructor de clase del objeto que se va a copiar para crear un segundo objeto con valores de propiedad tomado del primer objeto. Esto supone que los valores de un objeto están completamente definidos por su constructor de clase.

• Llame al método MemberwiseClone para crear una copia superficial de un objeto y, a continuación, asigne nuevos objetos cuyos valores son igual que el objeto original a las propiedades o campos cuyos valores sean los tipos de referencia. El método DeepCopy del ejemplo ilustra este enfoque.

• Serialice el objeto del que se va a hacer una copia profunda y, a continuación, restaure los datos serializados a una variable de objeto diferente.

• Utilice la reflexión con recursividad para realizar la operación de copia en profundidad.

En el siguiente ejemplo se muestra el método MemberwiseClone. Define un método ShallowCopy que llama al método MemberwiseClone para realizar una operación de copia superficial en un objeto Person. También define un método DeepCopy que realiza una operación de copia en profundidad en un objeto Person.

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(this.IdInfo.IdNumber);
       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 = (Person) 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

En este ejemplo, la propiedad Person.IdInfo devuelve un objeto IdInfo. Como muestra el resultado del ejemplo , cuando un objeto Person se clona llamando al método MemberwiseClone, el objeto Person clonado es una copia independiente del objeto original, solo que comparten la misma referencia de objeto Person.IdInfo. Como resultado, al modificar la propiedad Person.IdInfo del clon, se cambia la propiedad Person.IdInfo del objeto original. Por otro lado, cuando se realiza una operación de copia en profundidad, el objeto Person clonado, incluso su propiedad Person.IdInfo, se puede modificar sin afectar al objeto original.

.NET Framework

.NET Framework Client Profile

Biblioteca de clases portable

.NET para aplicaciones de la Tienda Windows

Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (no se admite el rol Server Core), Windows Server 2008 R2 (se admite el rol Server Core con SP1 o versiones posteriores; no se admite Itanium)

Referencia