C# 尝试在c中序列化和反序列化实体对象#

我使用以下两种方法来序列化/反序列化实体框架对象（4.0版）。 我尝试了几种方法来实现这一点，但没有成功。序列化工作正常。我得到了很好的xml格式的字符串，但当我尝试反序列化时，xml中出现了错误。这怎么可能

谢谢

    public static string SerializeObject(Object obj)
    {
        XmlSerializer ser = new XmlSerializer(obj.GetType());
        System.Text.StringBuilder sb = new System.Text.StringBuilder();
        System.IO.StringWriter writer = new System.IO.StringWriter(sb);
        ser.Serialize(writer, obj);
        XmlDocument doc = new XmlDocument();
        doc.LoadXml(sb.ToString());
        string xml = doc.InnerXml;
        return xml;
    }
    public static object DeSerializeAnObject(string xml, Type objType)
    {
        XmlDocument doc = new XmlDocument();
        doc.LoadXml(xml);
        XmlNodeReader reader = new XmlNodeReader(doc.DocumentElement);
        XmlSerializer ser = new XmlSerializer(objType);
        object obj = ser.Deserialize(reader);
        return obj;
    }

---

我认为问题在于这一行：

string xml = doc.InnerXml;

---

您需要所有xml，而不仅仅是根节点中的xml。

只需返回

sb.ToString（）

，加载到

XmlDocument

中并没有任何作用。

我使用通用方法来序列化和反序列化：

/// <summary>
/// Serializes an object to Xml as a string.
/// </summary>
/// <typeparam name="T">Datatype T.</typeparam>
/// <param name="ToSerialize">Object of type T to be serialized.</param>
/// <returns>Xml string of serialized type T object.</returns>
public static string SerializeToXmlString<T>(T ToSerialize)
{
    string xmlstream = String.Empty;

    using (MemoryStream memstream = new MemoryStream())
    {
        XmlSerializer xmlSerializer = new XmlSerializer(typeof(T));
        XmlTextWriter xmlWriter = new XmlTextWriter(memstream, Encoding.UTF8);

        xmlSerializer.Serialize(xmlWriter, ToSerialize);
        xmlstream = UTF8ByteArrayToString(((MemoryStream)xmlWriter.BaseStream).ToArray());
    }

    return xmlstream;
}

/// <summary>
/// Deserializes Xml string of type T.
/// </summary>
/// <typeparam name="T">Datatype T.</typeparam>
/// <param name="XmlString">Input Xml string from which to read.</param>
/// <returns>Returns rehydrated object of type T.</returns>
public static T DeserializeXmlString<T>(string XmlString)
{
    T tempObject = default(T);

    using (MemoryStream memoryStream = new MemoryStream(StringToUTF8ByteArray(XmlString)))
    {
        XmlSerializer xs = new XmlSerializer(typeof(T));
        XmlTextWriter xmlTextWriter = new XmlTextWriter(memoryStream, Encoding.UTF8);

        tempObject = (T)xs.Deserialize(memoryStream);
    }

    return tempObject;
} 

// Convert Array to String
public static String UTF8ByteArrayToString(Byte[] ArrBytes)
{ return new UTF8Encoding().GetString(ArrBytes); }
// Convert String to Array
public static Byte[] StringToUTF8ByteArray(String XmlString)
{ return new UTF8Encoding().GetBytes(XmlString); }

//
///将对象序列化为Xml字符串。
/// 
///数据类型T。
///要序列化的T类型的对象。
///序列化类型T对象的Xml字符串。
公共静态字符串SerializeToXmlString（T ToSerialize）
{
string xmlstream=string.Empty；
使用（MemoryStream memstream=new MemoryStream（））
{
XmlSerializer XmlSerializer=新的XmlSerializer（typeof（T））；
XmlTextWriter xmlWriter=新的XmlTextWriter（memstream，Encoding.UTF8）；
序列化（xmlWriter，ToSerialize）；
xmlstream=UTF8ByteArrayToString（（（MemoryStream）xmlWriter.BaseStream.ToArray（））；
}
返回xmlstream；
}
/// 
///反序列化T类型的Xml字符串。
/// 
///数据类型T。
///输入要从中读取的Xml字符串。
///返回类型为T的重新水化对象。
公共静态T反序列化XmlString（字符串XmlString）
{
T tempObject=默认值（T）；
使用（MemoryStream MemoryStream=新的MemoryStream（StringToUTF8ByteArray（XmlString）））
{
XmlSerializer xs=新的XmlSerializer（typeof（T））；
XmlTextWriter XmlTextWriter=新的XmlTextWriter（memoryStream，Encoding.UTF8）；
tempObject=（T）xs.反序列化（memoryStream）；
}
返回临时对象；
} 
//将数组转换为字符串
公共静态字符串UTF8ByteArrayToString（字节[]ArrBytes）
{返回新的UTF8Encoding（）.GetString（ArrBytes）；}
//将字符串转换为数组
公共静态字节[]StringToUTF8ByteArray（字符串XmlString）
{返回新的UTF8Encoding（）.GetBytes（XmlString）；}

一些冗余和使用被排除在外。重构和清理：

namespace MyProject
{
    using System.IO;
    using System.Text;
    using System.Xml;
    using System.Xml.Serialization;

    public static class Serializer
    {
        #region Public Methods and Operators

        /// <summary>
        ///     Deserializes Xml string of type T.
        /// </summary>
        /// <typeparam name="T">Datatype T.</typeparam>
        /// <param name="XmlString">Input Xml string from which to read.</param>
        /// <returns>Returns rehydrated object of type T.</returns>
        public static T DeserializeXmlString<T>(string xmlString)
        {
            T tempObject;

            using (var memoryStream = new MemoryStream(StringToUTF8ByteArray(xmlString)))
            {
                var xs = new XmlSerializer(typeof(T));
                tempObject = (T)xs.Deserialize(memoryStream);
            }

            return tempObject;
        }

        /// <summary>
        ///     Serializes an object to Xml as a string.
        /// </summary>
        /// <typeparam name="T">Datatype T.</typeparam>
        /// <param name="toSerialize">Object of type T to be serialized.</param>
        /// <returns>Xml string of serialized type T object.</returns>
        public static string SerializeToXmlString<T>(T toSerialize)
        {
            string xmlstream;

            using (var memstream = new MemoryStream())
            {
                var xmlSerializer = new XmlSerializer(typeof(T));
                var xmlWriter = new XmlTextWriter(memstream, Encoding.UTF8);

                xmlSerializer.Serialize(xmlWriter, toSerialize);
                xmlstream = UTF8ByteArrayToString(((MemoryStream)xmlWriter.BaseStream).ToArray());
            }

            return xmlstream;
        }

        #endregion

        #region Methods

        private static byte[] StringToUTF8ByteArray(string xmlString)
        {
            return new UTF8Encoding().GetBytes(xmlString);
        }

        private static string UTF8ByteArrayToString(byte[] arrBytes)
        {
            return new UTF8Encoding().GetString(arrBytes);
        }

        #endregion
    }
}

名称空间MyProject
{
使用System.IO；
使用系统文本；
使用System.Xml；
使用System.Xml.Serialization；
公共静态类序列化程序
{
#区域公共方法和运算符
/// 
///反序列化T类型的Xml字符串。
/// 
///数据类型T。
///输入要从中读取的Xml字符串。
///返回类型为T的重新水化对象。
公共静态T反序列化xmlString（字符串xmlString）
{
tempt对象；
使用（var memoryStream=new memoryStream（StringToUTF8ByteArray（xmlString）））
{
var xs=新的XmlSerializer（typeof（T））；
tempObject=（T）xs.反序列化（memoryStream）；
}
返回临时对象；
}
/// 
///将对象序列化为Xml字符串。
/// 
///数据类型T。
///要序列化的T类型的对象。
///序列化类型T对象的Xml字符串。
公共静态字符串SerializeToXmlString（T toSerialize）
{
字符串xmlstream；
使用（var memstream=new MemoryStream（））
{
var xmlSerializer=新的xmlSerializer（typeof（T））；
var xmlWriter=新的XmlTextWriter（memstream，Encoding.UTF8）；
序列化（xmlWriter，toSerialize）；
xmlstream=UTF8ByteArrayToString（（（MemoryStream）xmlWriter.BaseStream.ToArray（））；
}
返回xmlstream；
}
#端区
#区域方法
专用静态字节[]StringToUTF8ByteArray（字符串xmlString）
{
返回新的UTF8Encoding（）.GetBytes（xmlString）；
}
专用静态字符串UTF8ByteArrayToString（字节[]arrBytes）
{
返回新的UTF8Encoding（）.GetString（arrBytes）；
}
#端区
}
}

为什么要序列化

对象

；您可以将自定义类型序列化为Xml…错误：Xml文档中存在错误。Message=不是预期的。我后来添加了它。在网上的某个地方发现有人在做那件事。它不是双向工作的……我将使用

公共静态字符串序列化对象（这个t-toSerialize）

而不是

公共静态字符串序列化对象（t-toSerialize）

。