Serializzazione XML .NET

Question

Sto lavorando su una serie di classi che verranno utilizzate per serializzare in XML.L'XML non è controllato da me ed è organizzato piuttosto bene.Sfortunatamente, ci sono diversi set di nodi nidificati, lo scopo di alcuni di essi è semplicemente quello di contenere una raccolta dei propri figli.In base alla mia attuale conoscenza della serializzazione XML, tali nodi richiedono un'altra classe.

Esiste un modo per serializzare una classe su un insieme di nodi XML anziché su uno solo.Poiché mi sento come se fossi chiaro come il fango, diciamo che abbiamo l'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>

Idealmente, 3 lezioni sarebbero la cosa migliore.Una classe root con raccolte di user E group oggetti.Tuttavia, la cosa migliore che riesco a capire è che ho bisogno di un corso per root, users, user, groups E group, Dove users E groups contengono solo raccolte di user E group rispettivamente, e root contiene un users, E groups oggetto.

C'è qualcuno là fuori che ne sa più di me?(non mentire, so che ci sono).

Answer 1

Non stai usando il XmlSerializer?È dannatamente buono e rende davvero facile fare cose come questa (lo uso parecchio!).

Puoi semplicemente decorare le proprietà della tua classe con alcuni attributi e il resto è tutto fatto per te.

Hai preso in considerazione l'utilizzo di XmlSerializer o c'è un motivo particolare per cui no?

Ecco uno snippet di codice di tutto il lavoro necessario per serializzare quanto sopra (in entrambi i modi):

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

Answer 2

Avresti solo bisogno che gli Utenti siano definiti come un array di oggetti Utente.XmlSerializer lo renderà in modo appropriato per te.

Vedi questo link per un esempio:http://www.informit.com/articles/article.aspx?p=23105&seqNum=4

Inoltre, consiglierei di utilizzare Visual Studio per generare un XSD e utilizzare l'utilità della riga di comando XSD.EXE per visualizzare la gerarchia delle classi per te, come da http://quickstart.developerfusion.co.uk/quickstart/howto/doc/xmlserialization/XSDToCls.aspx

Answer 3

Ho scritto questo corso in passato per fare quello che penso sia simile a quello che stai cercando di fare tu.Utilizzeresti i metodi di questa classe sugli oggetti che desideri serializzare in XML.Ad esempio, dato un dipendente...

utilizzo delle Utilità;utilizzando System.Xml.Serialization;

Xmlroot ("dipendente")] dipendente di classe pubblica {Name di stringa privata = "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);
 }

}

questo codice dovrebbe restituire:

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

Il tipo di oggetto (Dipendente) deve essere serializzabile.Prova [Serializable(true)].Ho una versione migliore di questo codice da qualche parte, stavo appena imparando quando l'ho scritto.Ad ogni modo, controlla il codice qui sotto.Lo sto usando in qualche progetto, quindi funziona sicuramente.

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