C# 使用BinaryFormatter序列化和反序列化对象图

我正在尝试将对象图序列化为字符串，然后从字符串反序列化它。如果我这样做，对象序列化就很好了

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

Search；
字符串xml=ToString（this）；
s=FromString（xml）；
公共静态TType FromString（字符串输入）
{
var byteArray=Encoding.ASCII.GetBytes（输入）；
使用（var流=新内存流（byteArray））
{
var bf=新的二进制格式化程序（）；
返回（TType）bf.反序列化（流）；
}
}
公共静态字符串到字符串（TType数据）
{
使用（var ms=new MemoryStream（））
{
var bf=新的二进制格式化程序（）；
序列化（ms、数据）；
返回Encoding.ASCII.GetString（ms.GetBuffer（））；
}
}

抛出异常

没有对象类型“1936026741 Core.Sebring.BusinessObjects.Search.Search”的程序集ID

---

非常感谢您的帮助。谢谢。

这里有一些代码可以实现您想要的功能（我想）-但我必须问一下-为什么要序列化为这样的字符串

如果类足够简单，可以序列化为字符串，则使用更易于处理的XML序列化程序；如果你想将它序列化到磁盘，二进制文件将其写入文件，如果它复杂并且将其串行化为传输-考虑使用类似于原Buff.net之类的东西。 我认为问题的症结在于您试图使用ASCII编码——我使用的是Base64编码

不管怎样-现在开始（我刚刚猜到了你的搜索类！）

类程序
{
[可序列化]
公共类搜索
{
公共Guid ID{get；private set；}
公共搜索（）{}
公共搜索（Guid id）
{
ID=ID；
}
公共重写字符串ToString（）
{
返回ID.ToString（）；
}
}
静态void Main（字符串[]参数）
{
搜索=新搜索（Guid.NewGuid（））；
控制台写入线（搜索）；
string serialized=SerializeTest.SerializeToString（搜索）；
Search rehydrated=SerializeTest.DeSerializeFromString（序列化）；
控制台写入线（再水化）；
Console.ReadLine（）；
}
}
公共类序列化测试
{
公共静态编码_Encoding=Encoding.Unicode；
公共静态字符串SerializeToString（对象obj）
{
字节[]byteArray=二进制序列化对象（obj）；
返回Convert.tobase64字符串（byteArray）；
}
公共静态T反序列化FromString（字符串输入）
{
字节[]byteArray=Convert.FromBase64String（输入）；
返回BinaryDeserializeObject（byteArray）；
}
/// 
///获取字节数组并将其反序列化回其类型
/// 
///要反序列化到的类型
///将对象设置为字节数组
///反序列化类型
公共静态T BinaryDeserializeObject（字节[]serializedType）
{
if（serializedType==null）
抛出新ArgumentNullException（“serializedType”）；
if（serializedType.Length.Equals（0））
抛出新ArgumentException（“serializedType”）；
T反序列化对象；
使用（MemoryStream MemoryStream=新的MemoryStream（serializedType））
{
BinaryFormatter反序列化程序=新的BinaryFormatter（）；
反序列化对象=（T）反序列化器。反序列化（memoryStream）；
}
返回反序列化对象；
}
/// 
///获取对象并将其序列化为字节数组
/// 
///要序列化的对象
///将对象作为数组进行排序
公共静态字节[]二进制序列化对象（对象对象对象序列化）
{
if（objectToSerialize==null）
抛出新ArgumentNullException（“objectToSerialize”）；
字节[]序列化对象；
使用（MemoryStream stream=new MemoryStream（））
{
BinaryFormatter formatter=新的BinaryFormatter（）；
序列化（流、对象序列化）；
serializedObject=stream.ToArray（）；
}
返回序列化对象；
}
}

---

HTH

+1用于Base64编码（以ASCII字符串格式表示二进制数据）。Im序列化为字符串，以便将其存储在数据库中。如果有更好的方法，我愿意接受建议。你能更新原始问题以包含搜索类吗？当我不知道您试图序列化什么时，很难给出建议。

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

}