订购XElements

Question

我有以下可存储记录和错误的XML文档（可根据需要进行重新设计）。

<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> 
     <DETAIL>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> 

我想输出记录和错误，但显然必须按日期排序，以便它们按顺序排列。

如何按日期对它们进行排序，获取XElements的集合，然后对它们执行foreach循环？

Answer 1

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

Answer 2

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 
} 

Answer 3

了IEnumerable是不是很灵活，最好的办法可能是从枚举删除元素，对它们进行排序并重新插入它们，保持正确的顺序（相对于以前的邻居）。这是一个有点复杂，如果子元素是排序键

这将从IEnumerable的删除命名的元素，通过一个子元素进行排序（可能是也可能不是你所需要的），并重新插入他们在正确的地方。

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."); 
     } 
    }