Formatta stringa XML per stampare stringhe XML compatibili

Ho una stringa XML in quanto tale:

 Success 

Non ci sono linee tra un elemento e l’altro, e quindi è molto difficile da leggere. Voglio una funzione che formatta la stringa precedente:

    Success  

Senza ricorrere alla scrittura manuale della funzione di formattazione, c’è qualche libreria .Net o snippet di codice che posso usare a mano libera?

Usa XmlTextWriter …

 public static string PrintXML(string xml) { string result = ""; MemoryStream mStream = new MemoryStream(); XmlTextWriter writer = new XmlTextWriter(mStream, Encoding.Unicode); XmlDocument document = new XmlDocument(); try { // Load the XmlDocument with the XML. document.LoadXml(xml); writer.Formatting = Formatting.Indented; // Write the XML into a formatting XmlTextWriter document.WriteContentTo(writer); writer.Flush(); mStream.Flush(); // Have to rewind the MemoryStream in order to read // its contents. mStream.Position = 0; // Read MemoryStream contents into a StreamReader. StreamReader sReader = new StreamReader(mStream); // Extract the text from the StreamReader. string formattedXml = sReader.ReadToEnd(); result = formattedXml; } catch (XmlException) { // Handle the exception } mStream.Close(); writer.Close(); return result; } 

Dovrai analizzare il contenuto in qualche modo … Trovo che usare LINQ sia il modo più semplice per farlo. Di nuovo, tutto dipende dal tuo scenario esatto. Ecco un esempio funzionante con LINQ per formattare una stringa XML di input.

 string FormatXml(string xml) { try { XDocument doc = XDocument.Parse(xml); return doc.ToString(); } catch (Exception) { // Handle and throw if fatal exception here; don't just ignore them return xml; } } 

[usando le dichiarazioni per brevità]

Questo, da kristopherjohnson, è molto meglio:

  1. Non richiede nemmeno l’intestazione di un documento XML.
  2. Ha delle eccezioni più chiare
  3. Aggiunge opzioni di comportamento extra: OmitXmlDeclaration = true, NewLineOnAttributes = true
  4. Meno linee di codice

     static string PrettyXml(string xml) { var stringBuilder = new StringBuilder(); var element = XElement.Parse(xml); var settings = new XmlWriterSettings(); settings.OmitXmlDeclaration = true; settings.Indent = true; settings.NewLineOnAttributes = true; using (var xmlWriter = XmlWriter.Create(stringBuilder, settings)) { element.Save(xmlWriter); } return stringBuilder.ToString(); } 

Controlla il seguente link: Come stampare piuttosto XML (Sfortunatamente, il link ora restituisce 404 :()

Il metodo nel collegamento accetta una stringa XML come argomento e restituisce una stringa XML ben strutturata (rientrata).

Ho appena copiato il codice di esempio dal link per rendere questa risposta più completa e conveniente.

 public static String PrettyPrint(String XML) { String Result = ""; MemoryStream MS = new MemoryStream(); XmlTextWriter W = new XmlTextWriter(MS, Encoding.Unicode); XmlDocument D = new XmlDocument(); try { // Load the XmlDocument with the XML. D.LoadXml(XML); W.Formatting = Formatting.Indented; // Write the XML into a formatting XmlTextWriter D.WriteContentTo(W); W.Flush(); MS.Flush(); // Have to rewind the MemoryStream in order to read // its contents. MS.Position = 0; // Read MemoryStream contents into a StreamReader. StreamReader SR = new StreamReader(MS); // Extract the text from the StreamReader. String FormattedXML = SR.ReadToEnd(); Result = FormattedXML; } catch (XmlException) { } MS.Close(); W.Close(); return Result; } 

La soluzione semplice che sta funzionando per me:

  XmlDocument xmlDoc = new XmlDocument(); StringWriter sw = new StringWriter(); xmlDoc.LoadXml(rawStringXML); xmlDoc.Save(sw); String formattedXml = sw.ToString(); 

.NET 2.0 che ignora la risoluzione dei nomi e con il corretto smaltimento delle risorse, il rientro, lo spazio bianco di conservazione e la codifica personalizzata :

 public static string Beautify(System.Xml.XmlDocument doc) { string strRetValue = null; System.Text.Encoding enc = System.Text.Encoding.UTF8; // enc = new System.Text.UTF8Encoding(false); System.Xml.XmlWriterSettings xmlWriterSettings = new System.Xml.XmlWriterSettings(); xmlWriterSettings.Encoding = enc; xmlWriterSettings.Indent = true; xmlWriterSettings.IndentChars = " "; xmlWriterSettings.NewLineChars = "\r\n"; xmlWriterSettings.NewLineHandling = System.Xml.NewLineHandling.Replace; //xmlWriterSettings.OmitXmlDeclaration = true; xmlWriterSettings.ConformanceLevel = System.Xml.ConformanceLevel.Document; using (System.IO.MemoryStream ms = new System.IO.MemoryStream()) { using (System.Xml.XmlWriter writer = System.Xml.XmlWriter.Create(ms, xmlWriterSettings)) { doc.Save(writer); writer.Flush(); ms.Flush(); writer.Close(); } // End Using writer ms.Position = 0; using (System.IO.StreamReader sr = new System.IO.StreamReader(ms, enc)) { // Extract the text from the StreamReader. strRetValue = sr.ReadToEnd(); sr.Close(); } // End Using sr ms.Close(); } // End Using ms /* System.Text.StringBuilder sb = new System.Text.StringBuilder(); // Always yields UTF-16, no matter the set encoding using (System.Xml.XmlWriter writer = System.Xml.XmlWriter.Create(sb, settings)) { doc.Save(writer); writer.Close(); } // End Using writer strRetValue = sb.ToString(); sb.Length = 0; sb = null; */ xmlWriterSettings = null; return strRetValue; } // End Function Beautify 

Uso:

 System.Xml.XmlDocument xmlDoc = new System.Xml.XmlDocument(); xmlDoc.XmlResolver = null; xmlDoc.PreserveWhitespace = true; xmlDoc.Load("C:\Test.svg"); string SVG = Beautify(xmlDoc); 

Provai :

 internal static void IndentedNewWSDLString(string filePath) { var xml = File.ReadAllText(filePath); XDocument doc = XDocument.Parse(xml); File.WriteAllText(filePath, doc.ToString()); } 

sta funzionando bene come previsto.

se caricate XMLDoc sono abbastanza sicuro che la funzione .ToString () abbia un sovraccarico per questo.

Ma è questo per il debug? Il motivo per cui viene inviato in questo modo è di occupare meno spazio (ovvero rimuovere gli spazi bianchi non necessari dall’XML).

Output XML piuttosto personalizzabile con dichiarazione XML UTF-8

La seguente definizione di class fornisce un metodo semplice per convertire una stringa XML di input in un XML di output formattato con la dichiarazione xml come UTF-8. Supporta tutte le opzioni di configurazione offerte dalla class XmlWriterSettings .

 using System; using System.Text; using System.Xml; using System.IO; namespace CJBS.Demo { ///  /// Supports formatting for XML in a format that is easily human-readable. ///  public static class PrettyXmlFormatter { ///  /// Generates formatted UTF-8 XML for the content in the  ///  /// XmlDocument for which content will be returned as a formatted string /// Formatted (indented) XML string public static string GetPrettyXml(XmlDocument doc) { // Configure how XML is to be formatted XmlWriterSettings settings = new XmlWriterSettings { Indent = true , IndentChars = " " , NewLineChars = System.Environment.NewLine , NewLineHandling = NewLineHandling.Replace //,NewLineOnAttributes = true //,OmitXmlDeclaration = false }; // Use wrapper class that supports UTF-8 encoding StringWriterWithEncoding sw = new StringWriterWithEncoding(Encoding.UTF8); // Output formatted XML to StringWriter using (XmlWriter writer = XmlWriter.Create(sw, settings)) { doc.Save(writer); } // Get formatted text from writer return sw.ToString(); } ///  /// Wrapper class around  that supports encoding. /// Attribution: http://stackoverflow.com/a/427737/3063884 ///  private sealed class StringWriterWithEncoding : StringWriter { private readonly Encoding encoding; ///  /// Creates a new  with the specified encoding ///  ///  public StringWriterWithEncoding(Encoding encoding) { this.encoding = encoding; } ///  /// Encoding to use when dealing with text ///  public override Encoding Encoding { get { return encoding; } } } } } 

Possibilità di ulteriori miglioramenti: –

  • È ansible GetPrettyXml(XmlDocument doc, XmlWriterSettings settings) un metodo aggiuntivo GetPrettyXml(XmlDocument doc, XmlWriterSettings settings) che consente al chiamante di personalizzare l’output.
  • È ansible aggiungere un metodo aggiuntivo GetPrettyXml(String rawXml) che supporta l’analisi del testo non GetPrettyXml(String rawXml) , anziché utilizzare il client XmlDocument. Nel mio caso, avevo bisogno di manipolare l’XML usando XmlDocument, quindi non l’ho aggiunto.

Uso:

 String myFormattedXml = null; XmlDocument doc = new XmlDocument(); try { doc.LoadXml(myRawXmlString); myFormattedXml = PrettyXmlFormatter.GetPrettyXml(doc); } catch(XmlException ex) { // Failed to parse XML -- use original XML as formatted XML myFormattedXml = myRawXmlString; }