ansaurus

Question

Answer 1

A:

There are more than a few tutorials on XML file manipulation. Example of both save & load (reversed for tutorial, but both there):

http://www.java2s.com/Code/CSharp/XML/Loadxmldocumentfromxmlfile.htm

The steps should be roughly...

open Input file
Load input into XmlNodeList
Parse input into ouput XmlNodeList()
Save output into new file.

I actually think I see what your wanting, after a bit of staring... I'd have to tink about the parse step for a bit personally.

WernerCD 2010-09-14 03:04:55

`XmlNodeList` is, if not entirely obsolete, somewhat dated. The `XDocument`-related classes in LINQ to XML are generally more flexible.

Steven Sudit 2010-09-14 04:25:51

Answer 2

A:

If Xml output is what you're after, Xslt is probably your best bet. You'll need to load the xml and stylesheet into memory and then process accordingly. Something like:

// load the stylesheet
XslTransform stylesheet = new XslTransform();
stylesheet.Load(xsltFilePath);

// load the xml
XPathDocument doc = new XPathDocument(xmlFilePath);

//create the output stream
XmlTextWriter myWriter = new XmlTextWriter("output.xml", null);

// autobots! Transform!
stylesheet.Transform(doc, null, myWriter);        
myWriter.Close();

Regarding the stylesheet, I'm assuming that you'd be taking the last node in the xml file and then nesting the Equipment nodes from above. In order to do the recursive lookups, you'll need a special xslt feature that ships as part of the MSXML parser, specifically ms:node-set. This function let's you perform an xpath query and return a node rather than raw text.

Tip: Xslt is processed from the bottom up, so scroll down and then read-up.

PS -- I'm doing this from memory. Xslt can be finicky so you may want to play with this a bit.

<xsl:stylesheet version="1.0" 
                xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
                xmlns:ms="urn:schemas-microsoft-com:xslt"
                >

  <!-- wildcard: other content is copied as is -->
  <xsl:template match="node()|@*">
       <xsl:copy>
          <xsl:apply-templates select="node()|@*" />
       </xsl:copy>
  </xsl:template>

  <!-- this is our magic recursive template.  Any element that matches "Equipment"
       will caught and processed here. Everything else will default to our
       Wildcard above -->
  <xsl:template match="Equipment">

      <!-- Read the FromName element into the variable $fromName -->
      <xsl:variable name="fromName" select="FromName/text()" />

      <!-- Manually reconstruct the Equipment Node -->
      <Equipment>
         <!-- copy out FromName, Wire and Length -->
         <xsl:copy-of select="FromName" />
         <xsl:copy-of select="Wire" />
         <xsl:copy-of select="Length" />

         <!-- this is how we recursively pull our Element nodes in, which
              will match on this template -->
         <xsl:apply-templates select="ms:node-set('//' + $fromName')/Equipment" />

      </Equipment>

  </xsl:template>

  <!-- Starting point: Find the last node under system -->
  <xsl:template match="/System/*[last()]">
      <!-- copy the elements and attributes of this node to the output stream -->
      <xsl:copy>
           <!-- match templates on its contents -->
           <xsl:apply-templates select="node()|@*"/>
      </xsl:copy>

  </xsl:template>

</xsl:stylesheet>

bryanbcook 2010-09-14 04:05:11

-1 for giving out obsolete information. `XslTransform` and `new XmlTextWriter()` have been deprecated since .NET 2.0.

John Saunders 2010-09-14 04:21:32

Answer 3

A:

While it can be definitely compressed to a one-liner as Steven suggested :) I chose to sprawl around a bit to make it more understandable. Of course I still failed so I'll also explain a bit.

XDocument x = XDocument.Parse(xml);

Func<string, XName> xn = s => XName.Get(s, "");

var systems = x.Elements().First();
var equipments = x.Descendants(xn("Equipment"));
equipments.ToList().ForEach(e =>
{
        string fromName = e.Element(xn("FromName")).Value;
        var found = systems.Element(xn(fromName));
        if (found != null)
        {
            e.Add(found.Elements(xn("Equipment")));
            found.Remove();
    };
});

string result = x.ToString();

Assuming xml is the string in the OP, I simply parsed an XDocument from it. Then, a simple shortcut for getting XNames, since the code would have been even more crowded with it inline.

We get all the child elements of System and store it for later; for lack of a better term I called them systems. If there are multiple levels on which these elements may appear, the logic will of course need to be adjusted to find them all reliably.

Then we iterate through all the elements with the name Equipment (equipments), get the FromName element value, and search for an element with the same name in systems. If we find it, we simply add it to the current element and remove it from its parent; since the elements are still all part of the x tree, it works as expected.

Aaand... done. result is the desired result posted by the OP.

Alex Paven 2010-09-14 20:17:45

Why `x.Elements().First()` and not `X.Root`?

Steven Sudit 2010-09-14 21:31:06

Why define `xn` instead of using regular `XName.Get(s)` or even using `s` itself?

Steven Sudit 2010-09-14 21:33:19

For someone unfamiliar with Linq to XML I wanted to draw attention to the XName's namespace as well, because I used to had trouble with it in the beginning. And of course I should have used x.Root, yes. In my defense, it was very late.

Alex Paven 2010-09-15 05:40:57

Thanks! This helped!

CornCat 2010-09-15 14:39:16

ansaurus

tags:

views:

answers:

XML iteration and rearrangement- C#

related questions