versucht zu serialisieren und Deserialisieren von entity-Objekt in c#

Ich bin mit beiden folgenden Methoden zum serialisieren/Deserialisieren von entity framework-Objekt (ver. 4.0).
Ich habe versucht, mehrere Möglichkeiten, dies zu erreichen, und hatte kein Glück. Serialisierung funktioniert. Ich bekomme nette xml-formatierten string, aber wenn ich versuche zu Deserialisieren ich bekomme Fehler in der XML. Wie ist das möglich?

Dank.

    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;
    }
  • was ist der Fehler???
  • Warum sind Sie mit der Serialisierung eine object; Sie serialisieren können Ihre benutzerdefinierten Typ zu Xml...
  • Fehler: Es ist ein Fehler im XML-Dokument. Message=<ArrayOfProfileItemValidAnswerXref xmlns="> war nicht zu erwarten.
InformationsquelleAutor bobetko | 2011-06-30
  1. 8

    Ich die Verwendung generischer Methoden zum serialisieren und Deserialisieren:

    ///<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); }
    InformationsquelleAutor IAbstract
  2. 1

    ich DENKE, das Problem ist diese Zeile:

    string xml = doc.InnerXml;

    du willst, dass ALLE xml -, nicht nur die xml in den root-Knoten.

    • Ich fügte hinzu, dass später auf. Gefunden irgendwo im internet, dass jemand das Tat. Es funktioniert nicht in beide Richtungen...
    InformationsquelleAutor Chris Kooken
  3. 1

    Nur zurück sb.ToString(), laden in den XmlDocument ist nichts zu tun.

    InformationsquelleAutor Ben Robinson
  4. 0

    Einige Redundanzen und aufzuhalten der Benutzung ausgeschlossen wurde. Überarbeitete und aufgeräumt:

    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
    }
}
    • Ich würde public static string SerializeObject<T>(this T toSerialize) statt public static string SerializeObject<T>(T toSerialize).
    InformationsquelleAutor Thomas Hagström
Schreibe einen Kommentar