Formatage du XML créé par DataContractSerializer

Question

Existe-t-il un moyen simple de faire en sorte que DataContractSerializer produise du XML formaté plutôt qu'une longue chaîne de caractères ? Je ne veux pas modifier les balises ou le contenu de quelque manière que ce soit, mais simplement ajouter des sauts de ligne et des indentations pour rendre le XML plus lisible ?

<tagA>
   <tagB>This is</tagB>   
   <tagC>Much</tagC>
   <tagD>
      <tagE>easier to read</tagE>
   </tagD>
</tagA>

<tagA><tagB>This is</tagB><tagC>Much</tagC><tagD><tagE>harder to read</tagE></tagD></tagA>

Answer 1

Comme le dit bendewey, XmlWriterSettings est ce dont vous avez besoin - par exemple quelque chose comme

var ds = new DataContractSerializer(typeof(Foo));

var settings = new XmlWriterSettings { Indent = true };

using (var w = XmlWriter.Create("fooOutput.xml", settings))
    ds.WriteObject(w, someFoos);

Answer 2

Jetez un coup d'œil à la Indent de l XmlWriterSettings

Mise à jour : Voici un bon lien de MSDN sur Comment : Spécifier le format de sortie sur le XmlWriter

En outre, voici un échantillon :

class Program
{
    static void Main(string[] args)
    {
        var Mark = new Person()
        {
            Name = "Mark",
            Email = "mark@example.com"
        };

        var serializer = new DataContractSerializer(typeof(Person));

        var settings = new XmlWriterSettings()
        {
            Indent = true,
            IndentChars = "\t"
        };

        using (var writer = XmlWriter.Create(Console.Out, settings))
        {
            serializer.WriteObject(writer, Mark);
        }
        Console.ReadLine();
    }
}
public class Person
{
    public string Name { get; set; }
    public string Email { get; set; }
}

Answer 3

Faites attention à l'ajustement des espaces blancs dans les documents XML ! L'ajustement des espaces rend le XML plus lisible pour nous, les humains, mais il peut interférer avec l'analyse automatique.

Selon le Norme XML les espaces blancs sont importants par défaut. En d'autres termes, en ce qui concerne le XML, l'espace blanc est un contenu .

Si vous introduisez votre XML joliment formaté dans un objet Document XML, vous obtiendrez un résultat différent de celui de la version qui ne comporte ni espaces ni sauts de ligne. Vous obtiendrez des nœuds de texte supplémentaires ajoutés à la version qui a été formatée.

Cet article de MSDN sur Espace blanc XML propose plusieurs exemples qui montrent à quel point l'espace blanc peut être délicat.

Si vous formatez le XML uniquement pour la consommation humaine, cela n'a pas d'importance. Mais si vous essayez de faire le tour de votre document formaté, vous risquez d'avoir des problèmes.

Étant donné que l'un des principaux avantages de l'utilisation de DataContractSerializer est la possibilité de sérialiser des objets et de désérialiser du XML en toute transparence il est généralement préférable de ne pas toucher à la sortie la plus moche.

Je colle généralement la sortie dans NotePad++ et j'exécute une macro XML-tidy dessus lorsque je veux la lire à des fins de débogage.

Answer 4

    public static string SerializeEntity<T>(T source)
    {
        using (MemoryStream ms = new MemoryStream())
        {

                NetDataContractSerializer serializer = new NetDataContractSerializer();
                serializer.Serialize(ms, source);
                return System.Text.Encoding.ASCII.GetString(ms.ToArray());

        }
    }

    public static T DeSerializeEntity<T>(string xml)
    {
        using (MemoryStream ms = new MemoryStream(System.Text.Encoding.ASCII.GetBytes(xml)))
        {
                NetDataContractSerializer serializer = new NetDataContractSerializer();
                return (T)serializer.Deserialize(ms);
        }
    }

Answer 5

En se basant sur les autres exemples postés ici qui utilisent XmlWriter, voici une version (provenant de http://ClipFlair.codeplex.com ) qui fonctionne avec des flux (et la bibliothèque Ionic.Zip en particulier) et montre également comment le code est lorsque vous n'appliquez pas de formatage (en utilisant la compilation conditionnelle - il suffit de commenter le #define pour qu'il écrive du XML non formaté).

#define WRITE_FORMATTED_XML

using System.Xml;

namespace ClipFlair.Windows
{

  public partial class BaseWindow : FloatingWindow
  {

    //...

    #if WRITE_FORMATTED_XML
    private static XmlWriterSettings XML_WRITER_SETTINGS = new XmlWriterSettings() { Indent=true, IndentChars="  "};
    #endif

    //...

    public virtual void SaveOptions(ZipFile zip, string zipFolder = "") //THIS IS THE CORE SAVING LOGIC
    {
      if (SavingOptions != null) SavingOptions(this, null); //notify any listeners

      View.Busy = true;
      try
      {
        ZipEntry optionsXML = zip.AddEntry(zipFolder + "/" + View.GetType().FullName + ".options.xml",
          new WriteDelegate((entryName, stream) =>
          {
            DataContractSerializer serializer = new DataContractSerializer(View.GetType()); //assuming current View isn't null
            #if WRITE_FORMATTED_XML
            using (XmlWriter writer = XmlWriter.Create(stream, XML_WRITER_SETTINGS))
              serializer.WriteObject(writer, View);
            #else
            serializer.WriteObject(stream, View);
            #endif
          }));
      }
      catch (Exception e)
      {
        MessageBox.Show("ClipFlair options save failed: " + e.Message); //TODO: find the parent window
      }
      finally
      {
        View.Busy = false; //in any case (error or not) clear the Busy flag
      }

      if (SavedOptions != null) SavedOptions(this, null); //notify any listeners
    }

    //...

  }

}