Serialização XML .NET

Question

Estou trabalhando em um conjunto de classes que serão usadas para serializar em XML.O XML não é controlado por mim e está muito bem organizado.Infelizmente, existem vários conjuntos de nós aninhados, o objetivo de alguns deles é apenas manter uma coleção de seus filhos.Com base no meu conhecimento atual de serialização XML, esses nós exigem outra classe.

Existe uma maneira de serializar uma classe para um conjunto de nós XML em vez de apenas um.Porque sinto que estou sendo claro como lama, digamos que temos o 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 aulas seriam o melhor.Uma aula root com coleções de user e group objetos.No entanto, o melhor que posso imaginar é que preciso de uma aula para root, users, user, groups e group, onde users e groups contém apenas coleções de user e group respectivamente, e root contém um users, e groups objeto.

Alguém aí sabe melhor do que eu?(não minta, eu sei que existem).

Answer 1

Você não está usando o XMLSerializador?É muito bom e torna muito fácil fazer coisas assim (eu uso bastante!).

Você pode simplesmente decorar as propriedades de sua classe com alguns atributos e o resto é feito para você.

Você já pensou em usar o XmlSerializer ou há um motivo específico para não?

Aqui está um trecho de código de todo o trabalho necessário para serializar o item acima (nos dois sentidos):

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

Answer 2

Você só precisaria ter Usuários definidos como uma matriz de objetos Usuário.O XmlSerializer irá renderizá-lo adequadamente para você.

Veja este link para um exemplo:http://www.informit.com/articles/article.aspx?p=23105&seqNum=4

Além disso, eu recomendaria usar o Visual Studio para gerar um XSD e usar o utilitário de linha de comando XSD.EXE para exibir a hierarquia de classes para você, conforme http://quickstart.developerfusion.co.uk/quickstart/howto/doc/xmlserialization/XSDToCls.aspx

Answer 3

Eu escrevi esta aula naquela época para fazer o que eu acho, é semelhante ao que você está tentando fazer.Você usaria métodos desta classe em objetos que deseja serializar para XML.Por exemplo, dado um funcionário...

usando utilitários;usando System.Xml.Serialization;

Xmlroot ("funcionário")] funcionário da classe pública {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);
 }

}

este código deve gerar:

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

O tipo de objeto (Employee) deve ser serializável.Tente [Serializável (verdadeiro)].Eu tenho uma versão melhor desse código em algum lugar, estava aprendendo quando o escrevi.De qualquer forma, confira o código abaixo.Estou usando em algum projeto, então definitivamente funciona.

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