Ordering XElements

I have the following XML Document (that can be redesigned if necessary) that stores records and errors.

<MYROOT>  
  <RECORDS>
    <RECORD>
      <DATETIME>11/03/2010 14:12:41</DATETIME>
      <DOCUMENTID>1</DOCUMENTID>
    </RECORD>
    <RECORD>
      <DATETIME>11/03/2010 14:12:44</DATETIME>
      <DOCUMENTID>2</DOCUMENTID>
    </RECORD>
    <RECORD>
      <DATETIME>11/03/2010 14:12:45</DATETIME>
      <DOCUMENTID>3</DOCUMENTID>
    </RECORD>
  </RECORDS>
  <ERRORS>
    <ERROR TYPE="ERR">
      <DATETIME>11/03/2010 14:12:41</DATETIME>
      <DE开发者_StackOverflow社区TAIL>There has been a error on page 1</DETAIL>
    </ERROR>
    <ERROR TYPE="ERR">
      <DATETIME>11/03/2010 14:13:03</DATETIME>
      <DETAIL>There has been a error on page 101</DETAIL>
    </ERROR>
    <ERROR TYPE="SEQ">
      <DATETIME>11/03/2010 14:13:03</DATETIME>
      <DETAIL>Sequence Error, expected Sequence No. 101 Read 1</DETAIL>
    </ERROR>
  </ERRORS>
</MYROOT>

I want to output the records and errors but obviously have to sort them by date so they appear in order.

How can I sort them by date, get a collection of XElements and then just do a foreach loop over them?

XDocument xml = System.Xml.Linq.XDocument.Parse(YOUR_XML);
IEnumerable<XElement> records = xml.Root.Element("RECORDS").Elements();
IEnumerable<XElement> errors = xml.Root.Element("ERRORS").Elements();

IEnumerable<XElement> elements = from el in records.Concat(errors)
                                 orderby DateTime.Parse(el.Element("DATETIME").Value)
                                  select el;

foreach (XElement el in elements)
{
    // do something.
}

var elements = doc.Descendants("RECORD").Concat(doc.Descendants("ERROR")).
    OrderBy(x => DateTime.Parse(x.Element("DATETIME").Value));
foreach (XElement element in elements)
{
    // do something interesting with element
}

The IEnumerable is not very flexible, the best option may be to remove the elements from the enumerable, sort them and re-insert them, maintaining the correct order (relative to previous neighbors). It's a little more complicated if a sub element is the sort key

This will remove the named elements from the IEnumerable, sort them by a sub-element (may or may not be what you need) and re-insert them in the right place.

 private void SortIdNodes(XElement parent, String elementName, String sortElementname)
     {
         XNode prevElem = null;
         XNode nextElem = null;
         // Initial node count, to verify sets are equal
         int initialElementsCount = parent.Descendants().Count();
         List<XElement> unOrdered = parent.Descendants(elementName).ToList<XElement>();
         if (unOrdered.Count() < 2){
             return; // No sorting needed
         }
         // Make note of the neighbors
         prevElem = unOrdered[0].PreviousNode;
         nextElem = unOrdered.Last().NextNode;
         // Remove set from parent
         unOrdered.ForEach(el =>
         {
             el.Remove();
         });
         // Order the set, language (IEnumerable) semantics prevents us from changing order in place
         List <XElement> ordered =  unOrdered.OrderBy(x => x.Descendants(sortElementname).FirstOrDefault().Value).ToList<XElement>();
         // Add to parent in correct order
         if (prevElem != null)  // If there's a first neighbor
         {
             ordered.ForEach(el =>
             {
                 prevElem.AddAfterSelf(el);
                 prevElem = el;
             });
         }
         else if (nextElem != null)  // If there's only an end neighbor
         {
             ordered.Reverse();
             ordered.ForEach(el =>
             {
                 nextElem.AddBeforeSelf(el);
                 nextElem = el;
             });
         }
         else // we're the only children of the parent, just add
         {
             ordered.ForEach(el =>
             {
                 parent.Add(el); // add in order
             });
         }
         int finalElementCount = parent.Descendants().Count();
         if (initialElementsCount != finalElementCount)
         {
             throw new Exception("Error with element sorting, output collection not the same size as the input set.");
         }
     }