.NET XML-Serialisierung

Question

Ich arbeite an einer Reihe von Klassen, die verwendet werden, um XML zu serialisieren. Die XML wird nicht von mir gesteuert und ist ziemlich gut organisiert. Leider gibt es mehrere Sätze von verschachtelten Knoten sind, ist der Zweck nur einige von ihnen eine Sammlung ihrer Kinder zu halten. Basierend auf meiner derzeitigen Kenntnis von XML-Serialisierung, erfordern diese Knoten eine andere Klasse.

Gibt es eine Möglichkeit, eine Klasse serialisiert auf einen Satz von XML-Knoten statt nur möglich zu gestalten. Weil ich fühle mich wie ich so klar wie Schlamm mich zu sein, sagen wir haben das xml:

<root>
    <users>
        <user id="">
            <firstname />
            <lastname />
            ...
        </user>
        <user id="">
            <firstname />
            <lastname />
            ...
        </user>
    </users>
    <groups>
        <group id="" groupname="">
            <userid />
            <userid />
        </group>
        <group id="" groupname="">
            <userid />
            <userid />
        </group>
    </groups>
</root>

Im Idealfall drei Klassen am besten wären. Eine Klasse root mit Sammlungen von user und group Objekten. Allerdings Beste, was ich herausfinden kann, ist, dass ich brauche eine Klasse für root, users, user, groups und group, wo users und groups nur Sammlungen von user und group enthalten sind, und root enthält einen users und groups Objekt.

Jeder gibt, die besser ist als ich weiß? (Lüge nicht, ich weiß, es gibt).

Answer 1

Verwenden Sie nicht die XmlSerializer ? Es ist verdammt gut und macht die Dinge wie diese wirklich einfach zu tun (ich benutze es ziemlich viel!).

Sie können einfach Ihre Klasse Eigenschaften mit einigen Attributen schmücken und der Rest ist alles für Sie getan ..

Haben Sie mit XmlSerializer betrachtet oder gibt es einen besonderen Grund, warum nicht?

Hier ist ein Code-Snippet der alle erforderlichen Arbeiten der oben serialisiert werden (in beide Richtungen) zu bekommen:

[XmlArray("users"),
XmlArrayItem("user")]
public List<User> Users
{
    get { return _users; }
}

Answer 2

Sie würden nur benötigen Benutzer als ein Array von Benutzerobjekten definiert haben. Die XmlSerializer wird es machen in geeigneter Weise für Sie.

Siehe diesen Link für ein Beispiel: http://www.informit.com/articles/article.aspx? p = 23105 & SEQNUM = 4

Zusätzlich würde ich mit Visual Studio empfehlen eine XSD und mit dem Kommandozeilen-Utility xsd.exe zu generieren für Sie die Klassenhierarchie auszuspucken, wie pro http://quickstart.developerfusion.co.uk/quickstart/howto/doc/xmlserialization/XSDToCls.aspx

Answer 3

Ich schrieb diese Klasse bis zurück in den Tag zu tun, was ich denke, ist ähnlich zu dem, was Sie zu tun versuchen. Sie würden auf Objekte Methoden dieser Klasse verwenden, die Sie in XML serialisiert werden soll. Zum Beispiel gegeben Mitarbeiter ...

Dienstprogramme verwenden; mit System.Xml.Serialization;

[XmlRoot ( "Mitarbeiter")] public class Angestellter {      private String name = "Steve";

 [XmlElement("Name")]
 public string Name { get { return name; } set{ name = value; } }

 public static void Main(String[] args)
 {
      Employee e = new Employee();
      XmlObjectSerializer.Save("c:\steve.xml", e);
 }

}

Dieser Code ausgeben sollte:

<Employee>
  <Name>Steve</Name>
</Employee>

Der Objekttyp (Mitarbeiter) muss serialisierbar sein. Versuchen Sie [Serializable (true)]. Ich habe eine bessere Version dieses Codes irgendwo, ich war nur zu lernen, als ich es schrieb. Wie auch immer, überprüfen Sie den Code unten. Ich bin es in einem Projekt verwenden, so dass es funktioniert auf jeden Fall.

using System;
using System.IO;
using System.Xml.Serialization;

namespace Utilities
{
    /// <summary>
    /// Opens and Saves objects to Xml
    /// </summary>
    /// <projectIndependent>True</projectIndependent>
    public static class XmlObjectSerializer
    {
        /// <summary>
        /// Serializes and saves data contained in obj to an XML file located at filePath <para></para>        
        /// </summary>
        /// <param name="filePath">The file path to save to</param>
        /// <param name="obj">The object to save</param>
        /// <exception cref="System.IO.IOException">Thrown if an error occurs while saving the object. See inner exception for details</exception>
        public static void Save(String filePath, Object obj)
        {
            // allows access to the file
            StreamWriter oWriter =  null;

            try
            {
                // Open a stream to the file path
                 oWriter = new StreamWriter(filePath);

                // Create a serializer for the object's type
                XmlSerializer oSerializer = new XmlSerializer(obj.GetType());

                // Serialize the object and write to the file
                oSerializer.Serialize(oWriter.BaseStream, obj);
            }
            catch (Exception ex)
            {
                // throw any errors as IO exceptions
                throw new IOException("An error occurred while saving the object", ex);
            }
            finally
            {
                // if a stream is open
                if (oWriter != null)
                {
                    // close it
                    oWriter.Close();
                }
            }
        }

        /// <summary>
        /// Deserializes saved object data of type T in an XML file
        /// located at filePath        
        /// </summary>
        /// <typeparam name="T">Type of object to deserialize</typeparam>
        /// <param name="filePath">The path to open the object from</param>
        /// <returns>An object representing the file or the default value for type T</returns>
        /// <exception cref="System.IO.IOException">Thrown if the file could not be opened. See inner exception for details</exception>
        public static T Open<T>(String filePath)
        {
            // gets access to the file
            StreamReader oReader = null;

            // the deserialized data
            Object data;

            try
            {
                // Open a stream to the file
                oReader = new StreamReader(filePath);

                // Create a deserializer for the object's type
                XmlSerializer oDeserializer = new XmlSerializer(typeof(T));

                // Deserialize the data and store it
                data = oDeserializer.Deserialize(oReader.BaseStream);

                //
                // Return the deserialized object
                // don't cast it if it's null
                // will be null if open failed
                //
                if (data != null)
                {
                    return (T)data;
                }
                else
                {
                    return default(T);
                }
            }
            catch (Exception ex)
            {
                // throw error
                throw new IOException("An error occurred while opening the file", ex);
            }
            finally
            {
                // Close the stream
                oReader.Close();
            }
        }
    }
}