Serializzazione che modifica il contenuto dell'oggetto originale in C#

Question

Ho implementato un metodo di clonazione in profondità utilizzando un costruttore di copie in C#. Per verificare che funzioni, lo sto testando confrontando i risultati della serializzazione di un oggetto e del suo clone. La serializzazione è fatta in termini di un oggetto generico T. Ho anche provato in termini di un oggetto concreto e ottenere gli stessi risultati.

Ho un metodo per serializzare gli oggetti in array di byte

private byte[] ObjectToBytes(T obj) 
{ 
    BinaryFormatter formatter = new BinaryFormatter(); 
    using (MemoryStream stream = new MemoryStream()) 
    { 
     formatter.Serialize(stream, obj); 
     stream.Seek(0, SeekOrigin.Begin); 
     return stream.ToArray(); 
    } 
} 

Il seguente codice funziona bene.

T original = this.GetNewThing(); 
T clone = original.DeepClone(); 

// serialize after cloning 
byte[] originalBytes = ObjectToBytes(original); 
byte[] cloneBytes = ObjectToBytes(clone); 

bool equal = true; 
for (int i = 0; i < originalBytes.Length; i++) 
{ 
    if(originalBytes[i] != cloneBytes[i] 
    { 
     equal = false; 
     break; 
    } 
} 
equal == true; // True! 

Tuttavia, quando si passa all'ordine di quando gli oggetti sono serializzati, gli array di byte non sono più uguali.

// serialize before cloning 
T original = this.GetNewThing(); 
byte[] originalBytes = ObjectToBytes(original); 

T clone = original.DeepClone(); 
byte[] cloneBytes = ObjectToBytes(clone); 

bool equal = true; 
for (int i = 0; i < originalBytes.Length; i++) 
{ 
    if(originalBytes[i] != cloneBytes[i] 
    { 
     equal = false; 
     break; 
    } 
} 
equal == true; // False! 

Perché l'ordine di serializzazione influisce su questo? Ha qualcosa a che fare con gli oggetti BinaryFormatter o MemoryStream?

EDIT:

Ecco ciò che il metodo clone profonda sembra

public MyClass DeepClone() 
{ 
    return new MyClass(this); 
} 

e il costruttore utilizza assomiglia a questo

protected MyClass(MyClass myClass) 
{ 
    if (myClass == null) 
     throw new ArguementNullException("myclass"); 

    this.number = myClass.Number; 
    this.number2 = myClass.Number2; 
    this.number3 = myClass.Number3; 
} 

L'oggetto non è per nulla complesso mezzi. Tutti i valori copiati sono tipi di valori, quindi non ci sono tipi di riferimento che devono essere preoccupati.

Answer 1

DeepClone, o qualcosa che chiama a sua volta, sembra stia cambiando lo stato del vostro oggetto di origine.

Answer 2

è necessario modificare il metodo ObjectToBytes come segue:

private byte[] ObjectToBytes(Object obj) 
    { 
     if(obj == null) 
      return null; 

     BinaryFormatter bf = new BinaryFormatter(); 
     using(MemoryStream ms = new MemoryStream()) { 
      bf.Serialize(ms, obj); 

      return ms.ToArray(); 
     } 
    } 

Speranza che aiuta