使用BinaryFormatter序列化和反序列化對象圖

Question

我想序列化我的對象圖形爲一個字符串，然後從字符串反序列化它。如果我這樣做

using (var memStream = new System.IO.MemoryStream()) 
{ 
    mf.Serialize(memStream, this); 
    memStream.Seek(0, 0); 

    Search s; 
    using (var memStrClone = new System.IO.MemoryStream()) 
    { 
      memStream.CopyTo(memStrClone); 
      memStrClone.Seek(0, 0); 
      s = mf.Deserialize(memStrClone) as Search; 
    } 
} 

上面的代碼工作，但序列化到一個字符串，並嘗試反序列化這樣

Search s; 
string xml = ToString<Search>(this); 
s = FromString<Search>(xml); 

public static TType FromString<TType>(string input) 
{ 
    var byteArray = Encoding.ASCII.GetBytes(input); 
    using (var stream = new MemoryStream(byteArray)) 
    { 
      var bf = new BinaryFormatter(); 
      return (TType)bf.Deserialize(stream); 
    } 
} 

public static string ToString<TType>(TType data) 
{ 
    using (var ms = new MemoryStream()) 
    { 
      var bf = new BinaryFormatter(); 
      bf.Serialize(ms, data); 
      return Encoding.ASCII.GetString(ms.GetBuffer()); 
    } 
} 

相同的字符串拋出一個異常對象序列化就好

對象類型'1936026741 Core.Sebring.BusinessObjects.Search.Search'沒有程序集標識。

任何幫助，非常感謝。謝謝。

Answer 1

下面是一些代碼，它將做你想做的事（我認爲） - 但我必須問 - 爲什麼你想序列化成這樣的字符串？

如果該類足夠簡單，可以串行化爲一個字符串，則使用一個XML序列化程序更容易處理;如果你想將它序列化到磁盤上，二進制將它寫出到一個文件中，如果它很複雜並且你正在序列化它來傳輸 - 可以考慮使用類似protobuf-net的東西。

我認爲你問題的癥結在於你正在嘗試使用ASCII編碼 - 我使用的是Base64編碼。

反正 - 這裏去（我剛剛在你的搜索類的猜測！）

class Program 
{ 
    [Serializable] 
    public class Search 
    { 
     public Guid ID { get; private set; } 

     public Search() { } 

     public Search(Guid id) 
     { 
      ID = id; 
     } 

     public override string ToString() 
     { 
      return ID.ToString(); 
     } 
    } 

    static void Main(string[] args) 
    { 
     Search search = new Search(Guid.NewGuid()); 
     Console.WriteLine(search); 
     string serialized = SerializeTest.SerializeToString(search); 
     Search rehydrated = SerializeTest.DeSerializeFromString<Search>(serialized); 
     Console.WriteLine(rehydrated); 

     Console.ReadLine(); 
    } 
} 

public class SerializeTest 
{ 
    public static Encoding _Encoding = Encoding.Unicode; 

    public static string SerializeToString(object obj) 
    { 
     byte[] byteArray = BinarySerializeObject(obj); 
     return Convert.ToBase64String(byteArray); 
    } 

    public static T DeSerializeFromString<T>(string input) 
    { 
     byte[] byteArray = Convert.FromBase64String(input); 
     return BinaryDeserializeObject<T>(byteArray); 
    } 

    /// <summary> 
    /// Takes a byte array and deserializes it back to its type of <see cref="T"/> 
    /// </summary> 
    /// <typeparam name="T">The Type to deserialize to</typeparam> 
    /// <param name="serializedType">The object as a byte array</param> 
    /// <returns>The deserialized type</returns> 
    public static T BinaryDeserializeObject<T>(byte[] serializedType) 
    { 
     if (serializedType == null) 
      throw new ArgumentNullException("serializedType"); 

     if (serializedType.Length.Equals(0)) 
      throw new ArgumentException("serializedType"); 

     T deserializedObject; 

     using (MemoryStream memoryStream = new MemoryStream(serializedType)) 
     { 
      BinaryFormatter deserializer = new BinaryFormatter(); 
      deserializedObject = (T)deserializer.Deserialize(memoryStream); 
     } 

     return deserializedObject; 
    } 

    /// <summary> 
    /// Takes an object and serializes it into a byte array 
    /// </summary> 
    /// <param name="objectToSerialize">The object to serialize</param> 
    /// <returns>The object as a <see cref="byte"/> array</returns> 
    public static byte[] BinarySerializeObject(object objectToSerialize) 
    { 
     if (objectToSerialize == null) 
      throw new ArgumentNullException("objectToSerialize"); 

     byte[] serializedObject; 

     using (MemoryStream stream = new MemoryStream()) 
     { 
      BinaryFormatter formatter = new BinaryFormatter(); 
      formatter.Serialize(stream, objectToSerialize); 
      serializedObject = stream.ToArray(); 
     } 

     return serializedObject; 
    } 

} 

HTH