it-swarm.com.de

Formatieren Sie den XML-String in einen druckfähigen XML-String

Ich habe einen XML-String als solchen:

<?xml version='1.0'?><response><error code='1'> Success</error></response>

Es gibt keine Zeilen zwischen einem Element und einem anderen Element und ist daher sehr schwer zu lesen. Ich möchte eine Funktion, die den obigen String formatiert:

<?xml version='1.0'?>
<response>
<error code='1'> Success</error>
</response> 

Gibt es eine .Net-Bibliothek oder ein Codeausschnitt, die ich ohne weiteres verwenden kann, um die Formatierungsfunktion manuell zu schreiben?

145
Graviton

Verwenden Sie 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;
}
156
S M Kamran

Sie müssen den Inhalt irgendwie analysieren ... Ich finde LINQ am einfachsten. Wieder hängt alles von Ihrem genauen Szenario ab. Hier ein Arbeitsbeispiel, bei dem LINQ zum Formatieren einer Eingabe-XML-Zeichenfolge verwendet wird.

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

[Verwendung von Anweisungen sind der Kürze halber verboten]

271

Dieses hier, von Kristopherjohnson ist viel besser:

  1. Es ist auch kein XML-Dokumentheader erforderlich.
  2. Hat klarere Ausnahmen
  3. Fügt zusätzliche Verhaltensoptionen hinzu: OmitXmlDeclaration = true, NewLineOnAttributes = true
  4. Weniger Codezeilen

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

Überprüfen Sie den folgenden Link: Wie man XML hübsch druckt (Leider gibt der Link jetzt 404 zurück :()

Die Methode in der Verknüpfung nimmt einen XML-String als Argument und gibt einen wohlgeformten (eingerückten) XML-String zurück. 

Ich habe gerade den Beispielcode aus dem Link kopiert, um diese Antwort umfassender und bequemer zu machen. 

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;
}
6
Chansik Im

Die einfache Lösung, die für mich funktioniert:

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

.NET 2.0 ignoriert die Namensauflösung und mit der richtigen Ressourcenverfügbarkeit, dem Einrücken, dem Whitespace und der benutzerdefinierten Codierung

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

Verwendungszweck:

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

Ich habe es versucht:

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

es funktioniert gut wie erwartet.

2
Akhilesh singh

Anpassbare Hübsche XML-Ausgabe mit UTF-8-XML-Deklaration

Die folgende Klassendefinition bietet eine einfache Methode zum Konvertieren einer Eingabe-XML-Zeichenfolge in eine formatierte Ausgabe-XML mit der XML-Deklaration als UTF-8. Es unterstützt alle Konfigurationsoptionen, die die Klasse XmlWriterSettings bietet. 

using System;
using System.Text;
using System.Xml;
using System.IO;

namespace CJBS.Demo
{
    /// <summary>
    /// Supports formatting for XML in a format that is easily human-readable.
    /// </summary>
    public static class PrettyXmlFormatter
    {

        /// <summary>
        /// Generates formatted UTF-8 XML for the content in the <paramref name="doc"/>
        /// </summary>
        /// <param name="doc">XmlDocument for which content will be returned as a formatted string</param>
        /// <returns>Formatted (indented) XML string</returns>
        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();
        }



        /// <summary>
        /// Wrapper class around <see cref="StringWriter"/> that supports encoding.
        /// Attribution: http://stackoverflow.com/a/427737/3063884
        /// </summary>
        private sealed class StringWriterWithEncoding : StringWriter
        {
            private readonly Encoding encoding;

            /// <summary>
            /// Creates a new <see cref="PrettyXmlFormatter"/> with the specified encoding
            /// </summary>
            /// <param name="encoding"></param>
            public StringWriterWithEncoding(Encoding encoding)
            {
                this.encoding = encoding;
            }

            /// <summary>
            /// Encoding to use when dealing with text
            /// </summary>
            public override Encoding Encoding
            {
                get { return encoding; }
            }
        }
    }
}

Möglichkeiten zur weiteren Verbesserung: -

  • Es könnte eine zusätzliche Methode GetPrettyXml(XmlDocument doc, XmlWriterSettings settings) erstellt werden, mit der der Aufrufer die Ausgabe anpassen kann.
  • Eine zusätzliche Methode GetPrettyXml(String rawXml) könnte hinzugefügt werden, die die Analyse von unformatiertem Text unterstützt, anstatt dass der Client das XmlDocument verwendet. In meinem Fall musste ich das XML mit dem XmlDocument bearbeiten, daher habe ich das nicht hinzugefügt.

Verwendungszweck: 

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;
}
0
CJBS

wenn Sie das XMLDoc laden, bin ich mir ziemlich sicher, dass die .ToString () - Funktion eine Überladung dafür besitzt.

Aber ist das zum Debuggen? Der Grund dafür ist, dass er so gesandt wird, dass er weniger Speicherplatz beansprucht (d. H. Unnötiges Leerzeichen aus dem XML-Code entfernt).

0
Spence