c# - factura - secuencia cadena original

Formato de cadena XML para imprimir cadena XML amigable

Question

Tengo una cadena XML como tal:

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

No hay líneas entre un elemento y otro, y por lo tanto es muy difícil de leer. Quiero una función que formatea la cadena anterior:

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

Sin recurrir a escribir manualmente la función de formato, ¿hay alguna biblioteca .Net o fragmento de código que pueda usar de forma manual?

Answer 1

Salida XML bonita personalizable con declaración XML UTF-8

La siguiente definición de clase proporciona un método simple para convertir una cadena XML de entrada en XML de salida formateado con la declaración xml como UTF-8. Es compatible con todas las opciones de configuración que ofrece la clase XmlWriterSettings .

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://.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; }
            }
        }
    }
}

Posibilidades de mejora adicional:

• Se podría crear un método adicional GetPrettyXml(XmlDocument doc, XmlWriterSettings settings) que permita al llamador personalizar el resultado.
• Se podría agregar un método adicional GetPrettyXml(String rawXml) analizar el texto en bruto, en lugar de que el cliente use XmlDocument. En mi caso, necesitaba manipular el XML usando XmlDocument, por lo tanto, no agregué esto.

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

Answer 2

.NET 2.0 que ignora la resolución de nombres, y con eliminación de recursos adecuada, sangría, preserve-whitespace y codificación personalizada :

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

Answer 3

Consulte el siguiente enlace: Cómo imprimir bastante XML (Desafortunadamente, el enlace ahora devuelve 404 :()

El método en el enlace toma una cadena XML como argumento y devuelve una cadena XML bien formada (sangrada).

Acabo de copiar el código de muestra del enlace para hacer que esta respuesta sea más completa y 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;
}

Answer 4

Deberás analizar el contenido de alguna manera ... Me parece que usar LINQ es la manera más fácil de hacerlo. Nuevamente, todo depende de tu escenario exacto. Aquí hay un ejemplo de trabajo que utiliza LINQ para formatear una cadena XML de entrada.

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

[las declaraciones usando son omitidas por brevedad]

Answer 5

La solución simple que funciona para mí:

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

Answer 6

Lo intenté :

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

está funcionando bien como se esperaba.

Answer 7

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

Answer 8

si carga el XMLDoc, estoy bastante seguro de que la función .ToString () posee una sobrecarga para esto.

¿Pero esto es para la depuración? La razón por la que se envía así es para ocupar menos espacio (es decir, eliminar espacios en blanco innecesarios del XML).

Answer 9

Este, de kristopherjohnson es mucho mejor:

1. No requiere un encabezado de documento XML tampoco.
2. Tiene excepciones más claras
3. Agrega opciones de comportamiento adicionales: OmitXmlDeclaration = true, NewLineOnAttributes = true

4. Menos líneas de código

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