Cómo copiar una clase profunda sin marcar como Serializable

Question

Dada la siguiente clase:

class A 
{ 
    public List<B> ListB; 

    // etc... 
} 

donde B es otra clase que puede heredar/contener algunas otras clases.

---

Ante este escenario:

1. A es una clase grande y contiene muchos tipos de referencia
2. no puedo marcar B como [Serializable] como no tengo acceso al código fuente de B

---

Lo siguiente métodos para realizar una copia completa no funcionan:

1. no puedo usar ICloneable o MemberwiseClone como clase A contiene muchos tipos de referencia
2. no puedo escribir un constructor de copia para A, como la clase es grande y continua que se añade a , y contiene clases (como B) que no se pueden copiar profunda
3. no puedo utilizar la serialización ya que no puedo marcar una clase contenidos (como B, donde no hay código fuente disponible) como [Serializable]

---

¿Cómo puedo copiar profundamente la clase A?

Answer 1

he dejado de utilizar la serialización de una copia completa de todos modos, porque no hay suficiente control (no cada clase tiene que ser copiado de la misma manera). Luego comencé a implementar mis propias interfaces de copia profunda y copié todas las propiedades de la manera en que deberían copiarse.

formas típicas para copiar un tipo referenciado:

• uso constructor de copia
• el uso de métodos de fábrica (. Por ejemplo, tipos inmutables)
• utilizar su propio "clon"
• copia única referencia (por ejemplo, .otros Root-Type)
• crear nuevas propiedades de instancia y copia (p.tipos no escritas por sí mismo carece de un constructor de copia)

Ejemplo:

class A 
{ 
    // copy constructor 
    public A(A copy) {} 
} 

// a referenced class implementing 
class B : IDeepCopy 
{ 
    object Copy() { return new B(); } 
} 

class C : IDeepCopy 
{ 
    A A; 
    B B; 
    object Copy() 
    { 
    C copy = new C(); 

    // copy property by property in a appropriate way 
    copy.A = new A(this.A); 
    copy.B = this.B.Copy(); 
    } 
} 

Usted puede pensar que esto una enorme cantidad de trabajo. Pero al final, es fácil y directo, puede ajustarse donde sea necesario y hace exactamente lo que necesita.

Answer 2

¿No puede la serialización XML ayudarle?

Answer 3

¿No puedes hacer esto?

[Serializable] 
class A 
{ 
    ... 
    [NonSerialized] 
    public List<B> ListB; 
    .... 
} 

Y luego referirse a How do you do a deep copy of an object in .NET (C# specifically)? para una función de clonación

Answer 4

su interfaz IDeepCopy es exactamente lo que especifica ICloneable.

class B : ICloneable 
{ 
    public object Clone() { return new B(); } 
} 

y con una aplicación más amigable:

class B : ICloneable 
{ 
    public B Clone() { return new B(); } 
    // explicit implementation of ICloneable 
    object ICloneable.Clone() { return this.Clone(); } 
} 

Answer 5

puede probar esta. Funciona para mí

public static object DeepCopy(object obj) 
    { 
     if (obj == null) 
      return null; 
     Type type = obj.GetType(); 

     if (type.IsValueType || type == typeof(string)) 
     { 
      return obj; 
     } 
     else if (type.IsArray) 
     { 
      Type elementType = Type.GetType(
       type.FullName.Replace("[]", string.Empty)); 
      var array = obj as Array; 
      Array copied = Array.CreateInstance(elementType, array.Length); 
      for (int i = 0; i < array.Length; i++) 
      { 
       copied.SetValue(DeepCopy(array.GetValue(i)), i); 
      } 
      return Convert.ChangeType(copied, obj.GetType()); 
     } 
     else if (type.IsClass) 
     { 

      object toret = Activator.CreateInstance(obj.GetType()); 
      FieldInfo[] fields = type.GetFields(BindingFlags.Public | 
         BindingFlags.NonPublic | BindingFlags.Instance); 
      foreach (FieldInfo field in fields) 
      { 
       object fieldValue = field.GetValue(obj); 
       if (fieldValue == null) 
        continue; 
       field.SetValue(toret, DeepCopy(fieldValue)); 
      } 
      return toret; 
     } 
     else 
      throw new ArgumentException("Unknown type"); 
    } 

Gracias a DetoX83 article en el proyecto de código.

Answer 6

private interface IDeepCopy<T> where T : class 
    { 
     T DeepCopy(); 
    } 

    private class MyClass : IDeepCopy<MyClass> 
    { 
     public MyClass DeepCopy() 
     { 
      return (MyClass)this.MemberwiseClone(); 
     } 
    } 

Pluss: Yoy puede controlar el proceso de copia (si su clase tiene la propiedad identificadora puede establecerlos, o puede escribir otro código de lógica de negocio)

---

Menos: clase puede ser marcado como sellado

---

Answer 7

Un answer de un hilo diferente que nosotros La serialización json es la mejor que he visto.

public static T CloneJson<T>(this T source) 
{  
    if (Object.ReferenceEquals(source, null)) 
    { 
     return default(T); 
    }  
    return JsonConvert.DeserializeObject<T>(JsonConvert.SerializeObject(source)); 
} 

Answer 8

Trate de usar una secuencia de memoria para obtener una copia profunda de su objeto:

public static T MyDeepCopy<T>(this T source) 
      { 
       try 
       { 

        //Throw if passed object has nothing 
        if (source == null) { throw new Exception("Null Object cannot be cloned"); } 

        // Don't serialize a null object, simply return the default for that object 
        if (Object.ReferenceEquals(source, null)) 
        { 
         return default(T); 
        } 

        //variable declaration 
        T copy; 
        var obj = new DataContractSerializer(typeof(T)); 
        using (var memStream = new MemoryStream()) 
        { 
         obj.WriteObject(memStream, source); 
         memStream.Seek(0, SeekOrigin.Begin); 
         copy = (T)obj.ReadObject(memStream); 
        } 
        return copy; 
       } 
       catch (Exception) 
       { 
        throw; 
       } 
      } 

Here is more.