合併兩個XElements

Question

我不太清楚怎麼問這個，或者如果存在的話，但我有一個需要比其他同一個了結precendence合併兩個XElements，成爲一個元素。

的偏愛這裏是VB.NET和LINQ，但如果它演示瞭如何做到這一點沒有我的編碼人工挑開，並解決每一個元素和屬性的任何語言將是有益的。

例如，假設我有兩個元素。幽默我對他們是不同的，因爲他們是。

<HockeyPlayer height="6.0" hand="left"> 
<Position>Center</Position> 
<Idol>Gordie Howe</Idol> 
</HockeyPlayer> 

2.

<HockeyPlayer height="5.9" startinglineup="yes"> 
<Idol confirmed="yes">Wayne Gretzky</Idol> 
</HockeyPlayer> 

合併的結果將是

<HockeyPlayer height="6.0" hand="left" startinglineup="yes"> 
<Position>Center</Position> 
<Idol confirmed="yes">Gordie Howe</Idol> 
</HockeyPlayer> 

注意幾件事：height屬性VAL ＃1超過＃2。 hand屬性和值只是從＃1複製而來（它不存在於＃2中）。來自＃2的startinglineup屬性和值被複制（它不存在於＃1中）。 ＃1中的Position元素已被複制（它不存在於＃2中）。 ＃1中的Idol元素值覆蓋＃2，但＃2的屬性confirmed（它不存在於＃1中）被複制。

淨淨，＃1採取precendence在＃2，其中存在衝突（意味着兩者都具有相同的元件和/或屬性），並且其中不存在衝突，它們都拷貝到最終結果。

我試圖尋找這一點，但似乎無法找到任何東西，可能是因爲我使用的搜索詞是太普通。任何想法或解決方案（特別是Linq）？

Answer 1

以下是一個控制檯應用程序，用於生成問題中列出的結果。它使用遞歸來處理每個子元素。它沒有檢查的一件事是Elem2中出現的子元素不在Elem1中，但希望這可以幫助您開始尋找解決方案。

我不知道如果我會說這是最好的解決方案，但它確實工作。

Module Module1 

Function MergeElements(ByVal Elem1 As XElement, ByVal Elem2 As XElement) As XElement 

    If Elem2 Is Nothing Then 
     Return Elem1 
    End If 

    Dim result = New XElement(Elem1.Name) 

    For Each attr In Elem1.Attributes 
     result.Add(attr) 
    Next 

    Dim Elem1AttributeNames = From attr In Elem1.Attributes _ 
           Select attr.Name 

    For Each attr In Elem2.Attributes 
     If Not Elem1AttributeNames.Contains(attr.Name) Then 
      result.Add(attr) 
     End If 
    Next 

    If Elem1.Elements().Count > 0 Then 
     For Each elem In Elem1.Elements 
      result.Add(MergeElements(elem, Elem2.Element(elem.Name))) 
     Next 
    Else 
     result.Value = Elem1.Value 
    End If 

    Return result 
End Function 

Sub Main() 
    Dim Elem1 = <HockeyPlayer height="6.0" hand="left"> 
        <Position>Center</Position> 
        <Idol>Gordie Howe</Idol> 
       </HockeyPlayer> 

    Dim Elem2 = <HockeyPlayer height="5.9" startinglineup="yes"> 
        <Idol confirmed="yes">Wayne Gretzky</Idol> 
       </HockeyPlayer> 

    Console.WriteLine(MergeElements(Elem1, Elem2)) 
    Console.ReadLine() 
End Sub 

End Module 

編輯：我只注意到功能缺失As XElement。我真的很驚訝，它沒有這個工作！我每天都在使用VB.NET，但它有一些我仍然不完全明白的怪癖。

Answer 2

爲他人尋找同樣的東西的緣故，因爲我認爲人皆有貢獻早已失去了興趣......我需要做的類似，但多一點完整的東西。儘管如此，XMLDoc並沒有完全處理非元素內容，但我並不需要，因爲我的非元素內容不是文本就是不重要。隨意增強和重新發布... 哦，它的C＃4.0，因爲這就是我使用的...

/// <summary> 
/// Provides facilities to merge 2 XElement or XML files. 
/// <para> 
/// Where the LHS holds an element with non-element content and the RHS holds 
/// a tree, the LHS non-element content will be applied as text and the RHS 
/// tree ignored. 
/// </para> 
/// <para> 
/// This does not handle anything other than element and text nodes (infact 
/// anything other than element is treated as text). Thus comments in the 
/// source XML are likely to be lost. 
/// </para> 
/// <remarks>You can pass <see cref="XDocument.Root"/> if it you have XDocs 
/// to work with: 
/// <code> 
/// XDocument mergedDoc = new XDocument(MergeElements(lhsDoc.Root, rhsDoc.Root); 
/// </code></remarks> 
/// </summary> 
public class XmlMerging 
{ 
    /// <summary> 
    /// Produce an XML file that is made up of the unique data from both 
    /// the LHS file and the RHS file. Where there are duplicates the LHS will 
    /// be treated as master 
    /// </summary> 
    /// <param name="lhsPath">XML file to base the merge off. This will override 
    /// the RHS where there are clashes</param> 
    /// <param name="rhsPath">XML file to enrich the merge with</param> 
    /// <param name="resultPath">The fully qualified file name in which to 
    /// write the resulting merged XML</param> 
    /// <param name="options"> Specifies the options to apply when saving. 
    /// Default is <see cref="SaveOptions.OmitDuplicateNamespaces"/></param> 
    public static bool TryMergeXmlFiles(string lhsPath, string rhsPath, 
     string resultPath, SaveOptions options = SaveOptions.OmitDuplicateNamespaces) 
    { 
     try 
     { 
      MergeXmlFiles(lhsPath, rhsPath, resultPath); 
     } 
     catch (Exception) 
     { 
      // could integrate your logging here 
      return false; 
     } 
     return true; 
    } 

    /// <summary> 
    /// Produce an XML file that is made up of the unique data from both the LHS 
    /// file and the RHS file. Where there are duplicates the LHS will be treated 
    /// as master 
    /// </summary> 
    /// <param name="lhsPath">XML file to base the merge off. This will override 
    /// the RHS where there are clashes</param> 
    /// <param name="rhsPath">XML file to enrich the merge with</param> 
    /// <param name="resultPath">The fully qualified file name in which to write 
    /// the resulting merged XML</param> 
    /// <param name="options"> Specifies the options to apply when saving. 
    /// Default is <see cref="SaveOptions.OmitDuplicateNamespaces"/></param> 
    public static void MergeXmlFiles(string lhsPath, string rhsPath, 
     string resultPath, SaveOptions options = SaveOptions.OmitDuplicateNamespaces) 
    { 
     XElement result = 
      MergeElements(XElement.Load(lhsPath), XElement.Load(rhsPath)); 
     result.Save(resultPath, options); 
    } 

    /// <summary> 
    /// Produce a resulting <see cref="XElement"/> that is made up of the unique 
    /// data from both the LHS element and the RHS element. Where there are 
    /// duplicates the LHS will be treated as master 
    /// </summary> 
    /// <param name="lhs">XML Element tree to base the merge off. This will 
    /// override the RHS where there are clashes</param> 
    /// <param name="rhs">XML element tree to enrich the merge with</param> 
    /// <returns>A merge of the left hand side and right hand side element 
    /// trees treating the LHS as master in conflicts</returns> 
    public static XElement MergeElements(XElement lhs, XElement rhs) 
    { 
     // if either of the sides of the merge are empty then return the other... 
     // if they both are then we return null 
     if (rhs == null) return lhs; 
     if (lhs == null) return rhs; 

     // Otherwise build a new result based on the root of the lhs (again lhs 
     // is taken as master) 
     XElement result = new XElement(lhs.Name); 

     MergeAttributes(result, lhs.Attributes(), rhs.Attributes()); 

     // now add the lhs child elements merged to the RHS elements if there are any 
     MergeSubElements(result, lhs, rhs); 
     return result; 
    } 

    /// <summary> 
    /// Enrich the passed in <see cref="XElement"/> with the contents of both 
    /// attribute collections. 
    /// Again where the RHS conflicts with the LHS, the LHS is deemed the master 
    /// </summary> 
    /// <param name="elementToUpdate">The element to take the merged attribute 
    /// collection</param> 
    /// <param name="lhs">The master set of attributes</param> 
    /// <param name="rhs">The attributes to enrich the merge</param> 
    private static void MergeAttributes(XElement elementToUpdate, 
     IEnumerable<XAttribute> lhs, IEnumerable<XAttribute> rhs) 
    { 
     // Add in the attribs of the lhs... we will only add new attribs from 
     // the rhs duplicates will be ignored as lhs is master 
     elementToUpdate.Add(lhs); 

     // collapse the element names to save multiple evaluations... also why 
     // we ain't putting this in as a sub-query 
     List<XName> lhsAttributeNames = 
      lhs.Select(attribute => attribute.Name).ToList(); 
     // so add in any missing attributes 
     elementToUpdate.Add(rhs.Where(attribute => 
      !lhsAttributeNames.Contains(attribute.Name))); 
    } 

    /// <summary> 
    /// Enrich the passed in <see cref="XElement"/> with the contents of both 
    /// <see cref="XElement.Elements()"/> subtrees. 
    /// Again where the RHS conflicts with the LHS, the LHS is deemed the master. 
    /// Where the passed elements do not have element subtrees, but do have text 
    /// content that will be used. Again the LHS will dominate 
    /// </summary> 
    /// <remarks>Where the LHS has text content and no subtree, but the RHS has 
    /// a subtree; the LHS text content will be used and the RHS tree ignored. 
    /// This may be unexpected but is consistent with other .NET XML 
    /// operations</remarks> 
    /// <param name="elementToUpdate">The element to take the merged element 
    /// collection</param> 
    /// <param name="lhs">The element from which to extract the master 
    /// subtree</param> 
    /// <param name="rhs">The element from which to extract the subtree to 
    /// enrich the merge</param> 
    private static void MergeSubElements(XElement elementToUpdate, 
     XElement lhs, XElement rhs) 
    { 
     // see below for the special case where there are no children on the LHS 
     if (lhs.Elements().Count() > 0) 
     { 
      // collapse the element names to a list to save multiple evaluations... 
      // also why we ain't putting this in as a sub-query later 
      List<XName> lhsElementNames = 
       lhs.Elements().Select(element => element.Name).ToList(); 

      // Add in the elements of the lhs and merge in any elements of the 
      //same name on the RHS 
      elementToUpdate.Add(
       lhs.Elements().Select(
        lhsElement => 
         MergeElements(lhsElement, rhs.Element(lhsElement.Name)))); 

      // so add in any missing elements from the rhs 
      elementToUpdate.Add(rhs.Elements().Where(element => 
       !lhsElementNames.Contains(element.Name))); 
     } 
     else 
     { 
      // special case for elements where they have no element children 
      // but still have content: 
      // use the lhs text value if it is there 
      if (!string.IsNullOrEmpty(lhs.Value)) 
      { 
       elementToUpdate.Value = lhs.Value; 
      } 
      // if it isn't then see if we have any children on the right 
      else if (rhs.Elements().Count() > 0) 
      { 
       // we do so shove them in the result unaltered 
       elementToUpdate.Add(rhs.Elements()); 
      } 
      else 
      { 
       // nope then use the text value (doen't matter if it is empty 
       //as we have nothing better elsewhere) 
       elementToUpdate.Value = rhs.Value; 
      } 
     } 
    } 
}