Come copia completa una classe senza la marcatura come Serializable

Question

Data la seguente classe:

class A 
{ 
    public List<B> ListB; 

    // etc... 
} 

dove B è un'altra classe che può ereditare/contenere alcune altre classi.

---

Dato questo scenario:

1. A è una grande classe e contiene molti tipi di riferimento
2. non riesco a segnare B come [Serializable] come non ho accesso al codice sorgente di B

---

Quanto segue metodi per eseguire una copia profonda non funzionano:

1. non posso usare ICloneable o MemberwiseClone come classe A contiene molti tipi di riferimento
2. non posso scrivere un costruttore di copia per A, come la classe è grande e continuamente aggiunti , e contiene le classi (come B) che non possono essere copiati profonda
3. non posso usare la serializzazione come non riesco a segnare una classe contenuta (come B, dove nessun codice sorgente disponibile) come [Serializable]

---

Come è possibile copiare in profondità la classe A?

Answer 1

ho smesso di usare la serializzazione per la copia profonda in ogni caso, perché non c'è abbastanza controllo (non ogni classe deve essere copiato allo stesso modo). Poi ho iniziato a implementare le mie interfacce di copia profonda e copiare ogni proprietà nel modo in cui dovrebbe essere copiata.

modi tipici per copiare un tipo di riferimento:

• uso costruttore di copia
metodo fabbrica
• utilizzo (es. Tipi immutabili)
• utilizzare il proprio "clone"
• copiare solo di riferimento (ad esempio, altri tipi di root)
• creare una nuova istanza e copiare le proprietà (ad es.tipi non scritti da te manca un costruttore di copia)

Esempio:

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(); 
    } 
} 

si potrebbe pensare che questo è un enorme quantità di lavoro. Ma alla fine, è facile e diretto, può essere sintonizzato dove serve e fa esattamente quello che ti serve.

Answer 2

La serializzazione XML non ti può aiutare?

Answer 3

Non puoi farlo?

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

E poi fare riferimento a How do you do a deep copy of an object in .NET (C# specifically)? per una funzione di clonazione

Answer 4

l'interfaccia IDeepCopy è esattamente ciò che specifica ICloneable.

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

e con più implementazione amichevole:

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

Answer 5

si può provare questo. Funziona per me

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"); 
    } 

Grazie alla DetoX83 article sul progetto di codice.

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 in grado di controllare il processo di copia (se la vostra classe ha proprietà identificatore si possono impostare, oppure è possibile scrivere altro codice logica di business)

---

Minus: classe può essere contrassegnato come sigillato

---

Answer 7

Un answer da un thread diverso che noi la serializzazione di json è la migliore che abbia mai 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

Provare a usare un flusso di memoria per ottenere una copia completa del vostro oggetto:

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.