Indique XmlWriterSettings para usar etiquetas de cierre automático

Question

Estoy usando XmlWriterSettings para escribir Xml en el archivo. Tengo elementos con solo atributos, sin hijos. Los quiero a la salida como:

<element a="1" /> 

en lugar de

<element a="1"></element> 

¿Puedo hacerlo con XmlWriterSettings?

EDIT:

código es el siguiente:

private void Mission_Save(string fileName) 
    { 
     StreamWriter streamWriter = new StreamWriter(fileName, false); 
     streamWriter.Write(Mission_ToXml()); 
     streamWriter.Close(); 
     streamWriter.Dispose(); 

     _MissionFilePath = fileName; 
    } 

private string Mission_ToXml() 
    { 
     XmlDocument xDoc; 
     XmlElement root; 
     XmlAttribute xAtt; 

     xDoc = new XmlDocument(); 

     foreach (string item in _MissionCommentsBefore) 
      xDoc.AppendChild(xDoc.CreateComment(item)); 

     root = xDoc.CreateElement("mission_data"); 
     xAtt = xDoc.CreateAttribute("version"); 
     xAtt.Value = "1.61"; 
     root.Attributes.Append(xAtt); 
     xDoc.AppendChild(root); 

     //Out the xml's! 
     foreach (TreeNode node in _FM_tve_Mission.Nodes) 
      Mission_ToXml_private_RecursivelyOut(root, xDoc, node); 

     foreach (string item in _MissionCommentsAfter) 
      xDoc.AppendChild(xDoc.CreateComment(item)); 


     //Make this look good 
     StringBuilder sb = new StringBuilder(); 
     XmlWriterSettings settings = new XmlWriterSettings(); 

     settings.Indent = true; 
     settings.IndentChars = " "; 
     settings.NewLineChars = "\r\n"; 
     settings.NewLineHandling = NewLineHandling.Replace; 
     settings.OmitXmlDeclaration = true; 
     using (XmlWriter writer = XmlWriter.Create(sb, settings)) 
     { 
      xDoc.Save(writer); 
     } 

     return sb.ToString(); 
    } 

private void Mission_ToXml_private_RecursivelyOut(XmlNode root, XmlDocument xDoc, TreeNode tNode) 
    { 
     root.AppendChild(((MissionNode)tNode.Tag).ToXml(xDoc)); 
     foreach (TreeNode node in tNode.Nodes) 
      Mission_ToXml_private_RecursivelyOut(root, xDoc, node); 
    } 

aquí _FM_tve_Mission es un control TreeView que tiene nodos, cada uno de los nodos tiene una etiqueta de MissionNode clase, que tiene método un ToXml que devuelve XmlNode que contiene este MissionNode convierte a XML

Answer 1

Usted no necesita ninguna configuración especial para ello:

XmlWriter output = XmlWriter.Create(filepath); 
output.writeStartElement("element"); 
output.writeAttributeString("a", "1"); 
output.writeEndElement(); 

que le dará una salida de <element a="1" /> (Sólo probado en una aplicación que estoy trabajando en la escritura de XML para)

Básicamente si no añadir ningún dato antes de escribir el elemento final que se acaba de cerrar fuera para usted .

que también tienen las siguientes XmlWriterSettings puede ser uno de estos si isnt de trabajo por defecto:

XML

XmlWriterSettings wSettings = new XmlWriterSettings(); 
wSettings.Indent = true; 
wSettings.ConformanceLevel = ConformanceLevel.Fragment; 
wSettings.OmitXmlDeclaration = true; 
XmlWriter output = XmlWriter.Create(filePathXml, wSettings); 

Answer 2

procesamiento de un archivo externo, que escribió la siguiente clase para deshacerse de que no esté vacía cerrada Elementos. Mi XML ahora tiene etiquetas de cierre automático.

using System.Linq; 
using System.Xml.Linq; 

namespace XmlBeautifier 
{ 
    public class XmlBeautifier 
    { 
     public static string BeautifyXml(string outerXml) 
     { 
      var _elementOriginalXml = XElement.Parse(outerXml); 
      var _beautifiedXml = CloneElement(_elementOriginalXml); 
      return _beautifiedXml.ToString(); 
     } 

     public static XElement CloneElement(XElement element) 
     { 
      // http://blogs.msdn.com/b/ericwhite/archive/2009/07/08/empty-elements-and-self-closing-tags.aspx 
      return new XElement(element.Name, 
       element.Attributes(), 
       element.Nodes().Select(n => 
       { 
        XElement e = n as XElement; 
        if (e != null) 
         return CloneElement(e); 
        return n; 
       }) 
      ); 
     } 

    } 
} 

Answer 3

Con expresiones regulares y el método recursivo, es tarea fácil:

using System.Xml.Linq; 
    public static class Xml 
    { 
     /// <summary> 
     /// Recursive method to shorten all xml end tags starting from a given element, and running through all sub elements 
     /// </summary> 
     /// <param name="elem">Starting point element</param> 
     public static void ToShortEndTags(this XElement elem) 
     { 
      if (elem == null) return; 

      if (elem.HasElements) 
      { 
       foreach (var item in elem.Elements()) ToShortEndTags(item); 
       return; 
      } 

      var reduced = Regex.Replace(elem.ToString(), ">[\\s\\n\\r]*</\\w+>", "/>"); 

      elem.ReplaceWith(XElement.Parse(reduced)); 
     } 
    } 

Y para usarlo Escribe algo como esto:

var path = @"C:\SomeFile.xml"; 
    var xdoc = XDocument.Load(path).Root.ToShortEndTags(); 

xdoc es ahora, una instancia de XDocument cargados desde una ruta determinada, pero todos sus elementos elegibles (sin contenido) Etiquetas de finalización completa ahora son Corto ened