Kolayca XML dizesi yazdırmak için XML dizesini biçimlendirme

Ben böyle bir XML dizesi var:

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

Bir öğe ile bir diğeri arasında hiç çizgi yoktur ve bu nedenle okunması çok zordur. Yukarıdaki dizeyi biçimlendiren bir işlev istiyorum:

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

Biçim işlevini kendim el ile yazmak için başvurmadan, hazırlıksız kullanabileceğim herhangi bir .Net kütüphanesi veya kod snippet'i var mı?

Kullanın 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;
}

İçeriği bir şekilde ayrıştırmanız gerekecek ... Bunu yapmanın en kolay yolunu LINQ kullanarak buluyorum. Yine, her şey sizin kesin senaryonuza bağlıdır. Girilen bir XML dizesini biçimlendirmek için LINQ kullanan çalışan bir örnek.

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

[kısalık için ifadeler kullanılıyor]

Kristopherjohnson'dan bu daha iyi yığınlar:

1. Bir XML belge başlığı da gerektirmez.
2. Daha net istisnaları vardır
3. Ek davranış seçenekleri ekler: OmitXmlDeclaration = true, NewLineOnAttributes = true

4. Daha az kod satırı

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

Benim için çalışan basit çözüm:

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

Aşağıdaki bağlantıyı kontrol edin: XML nasıl güzel yazdırılır (Maalesef, bağlantı şimdi 404 döndürüyor :()

Bağlantıdaki yöntem, bir XML dizesini bağımsız değişken olarak alır ve iyi biçimlendirilmiş (girintili) bir XML dizesi döndürür.

Bu cevabı daha kapsamlı ve kullanışlı hale getirmek için bağlantıdan örnek kodu kopyaladım.

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

Denedim:

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

beklendiği gibi iyi çalışıyor.

.NET 2.0, ad çözümlemeyi yok sayıyor ve uygun kaynak imhası, girintileme, koruma alanı ve özel kodlama ile :

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

Kullanımı:

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

XMLDoc'u yüklerseniz .ToString () işlevinin bunun için bir aşırı yük içerdiğinden eminim.

Ama bu hata ayıklama için mi? Bunun gibi gönderilmesinin nedeni daha az yer kaplamaktır (yani gereksiz boşlukları XML'den çıkarmak).

UTF-8 XML bildirimi ile özelleştirilebilir Pretty XML çıkışı

Aşağıdaki sınıf tanımı, giriş XML dizesini xml bildirimi ile UTF-8 olarak biçimlendirilmiş çıkış XML'sine dönüştürmek için basit bir yöntem sağlar. XmlWriterSettings sınıfının sunduğu tüm yapılandırma seçeneklerini destekler .

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

Daha da geliştirilmesi için olanaklar: -

• GetPrettyXml(XmlDocument doc, XmlWriterSettings settings)Arayanın çıktıyı özelleştirmesine izin veren ek bir yöntem oluşturulabilir.
• GetPrettyXml(String rawXml)İstemcinin XmlDocument'i kullanmasından ziyade ham metni ayrıştırmayı destekleyen ek bir yöntem eklenebilir. Benim durumumda, XmlDocument kullanarak XML manipüle etmek gerekiyordu, bu yüzden bunu eklemedim.

Kullanımı:

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