Sérialisation XML .NET

Question

Je travaille sur un ensemble de classes qui seront utilisées pour sérialiser en XML. Le XML n'est pas contrôlé par moi et est plutôt bien organisé. Malheureusement, il existe plusieurs ensembles de noeuds imbriqués. Certains d'entre eux ont simplement pour but de contenir une collection de leurs enfants. D'après mes connaissances actuelles en sérialisation XML, ces nœuds nécessitent une autre classe.

Existe-t-il un moyen de sérialiser une classe sur un ensemble de nœuds XML au lieu d’un seul. Parce que je sens que je suis aussi clair que de la boue, disons que nous avons le 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>

Idéalement, 3 classes seraient les meilleures. Une classe root avec des collections d'objets utilisateur et groupe . Cependant, la meilleure chose à faire, c’est que j’ai besoin d’une classe pour racine , utilisateurs , utilisateur , groupes et < code> groupe , où utilisateurs et groupes ne contiennent que des collections de utilisateur et de groupe , et root contient un objet users et un objet groups .

Quelqu'un qui sait mieux que moi? (ne mentez pas, je sais qu'il y en a).

Answer 1

N'utilisez-vous pas le XmlSerializer ? C'est sacrément bon et ça rend vraiment facile de faire des choses comme ça (je l'utilise beaucoup!).

Vous pouvez simplement décorer vos propriétés de classe avec certains attributs et tout le reste est fait pour vous.

Avez-vous envisagé d'utiliser XmlSerializer ou existe-t-il une raison particulière pour laquelle ne pas l'utiliser?

Voici un extrait de code de tout le travail requis pour la sérialisation de ce qui précède (dans les deux sens):

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

Answer 2

Il vous suffira de définir les utilisateurs comme un tableau d'objets utilisateur. XmlSerializer le rendra correctement pour vous.

Voir ce lien pour un exemple: http://www.informit.com/articles/article.aspx? p = 23105 & amp; seqNum = 4

En outre, je vous recommanderais d'utiliser Visual Studio pour générer un fichier XSD et d'utiliser l'utilitaire de ligne de commande XSD.EXE pour décomposer la hiérarchie des classes, comme indiqué dans http://quickstart.developerfusion.co.uk/quickstart/howto/doc/xmlserialization/XSDToCls.aspx

Answer 3

J'ai écrit cette classe à la fin de la journée pour faire ce que je pense, est similaire à ce que vous essayez de faire. Vous utiliseriez les méthodes de cette classe sur les objets que vous souhaitez sérialiser en XML. Par exemple, étant donné un employé ...

using Utilities; using System.Xml.Serialization;

[XmlRoot ("Employé")] Classe publique Employé {      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);
 }

}

ce code doit générer:

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

Le type d'objet (Employé) doit être sérialisable. Essayez [Serializable (true)]. J'ai une meilleure version de ce code quelque part, j'apprenais juste quand je l'ai écrit. Quoi qu'il en soit, consultez le code ci-dessous. Je l'utilise dans certains projets, donc ça marche vraiment.

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