एक्सएमएल सॉर्टिंग/स्वरूपण उपकरण

Question

क्या कोई ऐसा उपकरण है जो (सुंदर प्रिंट) प्रारूप XML फ़ाइल के साथ-साथ इसके तत्वों और विशेषताओं दोनों को सॉर्ट कर सकता है?

Answer 1

मैं इस पोस्ट पाया है: http://www.biglist.com/lists/xsl-list/archives/200106/msg01225.html मांगपत्र एक्सएमएल के लिए निम्न XSLT का उपयोग करता है और यह भी तरह जिम्मेदार बताते हैं कि:

<?xml version="1.0"?> 
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0"> 

    <xsl:output method="xml" indent="yes"/> 
    <xsl:strip-space elements="*"/> 

    <xsl:template match="/"> 
    <xsl:apply-templates/> 
    </xsl:template> 

    <xsl:template match="*"> 
    <xsl:copy> 
     <!-- Sort the attributes by name. --> 
     <xsl:for-each select="@*"> 
     <xsl:sort select="name(.)"/> 
     <xsl:copy/> 
     </xsl:for-each> 
     <xsl:apply-templates/> 
    </xsl:copy> 
    </xsl:template> 

    <xsl:template match="text()|comment()|processing-instruction()"> 
    <xsl:copy/> 
    </xsl:template> 

</xsl:stylesheet> 

मैं अभी तक इसे करने की कोशिश नहीं की है, लेकिन सबसे अधिक संभावना मैं XSLT से चिपके स्वरूपण करने के लिए होगा मेरे लिए।

Answer 2

मैं एक समान उपयोगिता की तलाश में था और वास्तव में वह नहीं मिला जो मैं खोज रहा था, इसलिए मैंने बस इसके बजाय एक लिखा है। यह बहुत आसान है (और नोड सॉर्टिंग में विशेषताओं को शामिल नहीं करता है), लेकिन काम करता है।

शायद यह दूसरों के लिए उपयोगी होगा .. यह GitHub पर है।

यहाँ GitHub पेज से एक सा है ...

USAGE: sortxml.exe [options] infile [outfile] 

    infile  The name of the file to sort, etc. 
    outfile  The name of the file to save the output to. 
       If this is omitted, then the output is written to stdout. 

OPTIONS: 

    --pretty Ignores the input formatting and makes the output look nice. 
    --sort  Sort both the nodes and attributes. 
    --sortnode Sort the nodes. 
    --sortattr Sort the attributes. 

(prefix an option with ! to turn it off.) 

डिफ़ॉल्ट उत्पादन सुंदर और हल कर नोड्स और गुण है। यहाँ एक उदाहरण है: https://xmlsorter.codeplex.com/

आप टैग के नाम और विशेषताओं के आधार पर क्रमबद्ध कर सकते हैं:

> type sample.xml 
<?xml version="1.0" encoding="utf-8" ?><root><node value="one" attr="name"/></root> 

> sortxml.exe sample.xml 
<?xml version="1.0" encoding="utf-8"?> 
<root> 
    <node attr="name" value="one" /> 
</root> 

Answer 3

मैं इस उपकरण पसंद आया। मैं कुछ एक्सएमएल फाइलों की तुलना करने से पहले इसका इस्तेमाल करना चाहता हूं।

Answer 4

जो पुन: व्यवस्थित करने के लिए & पुनर्लेखन edmx-फ़ाइलें (इकाई की रूपरेखा) हर समय लगता है दृश्य स्टूडियो के साथ हताशा से बाहर (भी इस Uservoice देखें), मैं सामान को पुन: व्यवस्थित करने के लिए कुछ LINQPad-कोड लिखा था। यह लिंककैड के बाहर उपयोग करने के लिए हालांकि आसान (और स्पष्ट) है।

यह तत्व-प्रकार (टैग) द्वारा तत्वों को ऑर्डर करता है, फिर तत्व-विशेषता "नाम" के मान से, और उसके बाद कुछ अन्य चीजों द्वारा इसे निर्धारक (विभिन्न xml, लेकिन समान अर्थ) , [आमतौर पर] एक ही आउटपुट है - कोड देखें)।

यह गुणों का भी आदेश देता है। ध्यान दें कि शब्दार्थ एक्सएमएल-गुण नहीं (प्रासंगिक) आदेश है, लेकिन टेक्स्ट रूप वे करते हैं, और संस्करण नियंत्रण प्रणाली अभी भी उन्हें सादा पाठ पर विचार ...

(ध्यान दें कि यह अलग उपनाम का समाधान नहीं होता, Entity Framework edmx file regenerating differently amongst team में उल्लेख किया है)

void Main() 
{ 
    XDocument xdoc = XDocument.Load(@"\\filepath1\file1.edmx"); 

    var orderedElements = CopyAndSortElements(xdoc.Elements()); 

    var newDoc = new XDocument(); 
    newDoc.Add(orderedElements); 
    newDoc.Save(@"\\filepath1\file1.Ordered.edmx"); 
} 

public IEnumerable<XElement> CopyAndSortElements(IEnumerable<XElement> elements) 
{ 
    var newElements = new List<XElement>(); 
    // Sort XElements by Tag & name-attribute (and some other properties) 
    var orderedElements = elements.OrderBy(elem => elem.Name.LocalName) // element-tag 
            .ThenByDescending(elem => elem.Attributes("Name").Count()) // can be 0, more than 1 is invalid XML 
            .ThenBy(elem => (elem.Attributes("Name").Any() ? elem.Attributes("Name").First().Value.ToString() : string.Empty)) 
            // in case of no Name-Attributes, try to sort by (number of) children 
            .ThenBy(elem => elem.Elements().Count()) 
            .ThenBy(elem => elem.Attributes().Count()) 
            // next line may vary for textually different but semantically equal input when elem & attr were unordered on input, but I need to restrain myself... 
            .ThenBy(elem => elem.ToString()); 
    foreach (var oldElement in orderedElements) 
    { 
     var newElement = new XElement(oldElement.Name); 
     var orderedAttrs = oldElement.Attributes().OrderBy(attr => attr.Name.LocalName).ThenBy(attr => attr.Value.ToString()); 
     newElement.Add(orderedAttrs); 
     newElement.Add(CopyAndSortElements(oldElement.Elements())); 
     newElements.Add(newElement); 
    } 
    return newElements; 
} 

पुनश्च: हम एक XSLT, जो किसी और एक ही समय में लिखा का उपयोग कर समाप्त हो गया। मुझे लगता है कि यह हर किसी की निर्माण प्रक्रिया में आसान/बेहतर फिट बैठता है। लेकिन शायद/उम्मीद है कि यह किसी के लिए कुछ उपयोग है।

Answer 5

फ़ाइल को क्रमबद्ध करने और संपादित करने का तरीका जानने के दौरान मैं इस पोस्ट में आया था। मेरे समाधान Arvo Bowens समाधान पर आधारित था पाया https://stackoverflow.com/a/19324438/212241

void Main() 
{ 
    XDocument xdoc = XDocument.Load(@"C:\git\Nvision\Source\NvisionEntities\NvisionModel.edmx"); 
    Sort(xdoc.Root); 
    xdoc.Save(@"C:\git\Nvision\Source\NvisionEntities\NvisionModel.edmx"); 
} 

public void Sort(XElement source, bool bSortAttributes = true) 
{ 
    //Make sure there is a valid source 
    if (source == null) throw new ArgumentNullException("source"); 

    //Sort attributes if needed 
    if (bSortAttributes) 
    { 
     List<XAttribute> sortedAttributes = source.Attributes().OrderBy(a => a.ToString()).ToList(); 
     sortedAttributes.ForEach(a => a.Remove()); 
     sortedAttributes.ForEach(a => source.Add(a)); 
    } 

    //Sort the children IF any exist 
    List<XElement> sortedChildren = source.Elements().OrderBy(elem => elem.Attributes("Name").Any() ? elem.Attributes("Name").First().Value.ToString() : string.Empty).ToList(); 
    if (source.HasElements) 
    { 
     source.RemoveNodes(); 
     sortedChildren.ForEach(c => Sort(c)); 
     sortedChildren.ForEach(c => source.Add(c)); 
    } 
}