C# XmlMerger.MergeInner方法代码示例

 public void XmlMergerDoesNotCallImmutableElementMergeServiceForMutableElement()
 {
     var listener = new ListenerForUnitTests();
     var merger = new XmlMerger(new NullMergeSituation())
     {
         EventListener = listener
     };
     var elemStrat = new ElementStrategy(false)
     {
         IsImmutable = false
     };
     merger.MergeStrategies.SetStrategy("MutableElemment", elemStrat);
     var ancestor = CreateNode("<MutableElemment attr='originalvalue' />");
     var ours = CreateNode("<MutableElemment attr='ourvalue' />");
     var theirs = CreateNode("<MutableElemment attr='originalvalue' />");
     merger.MergeInner(ref ours, theirs, ancestor);
     Assert.AreNotSame(ancestor, ours);
     Assert.AreEqual("<MutableElemment attr=\"ourvalue\" />", ours.OuterXml);
     listener.AssertExpectedChangesCount(1);
     listener.AssertFirstChangeType<XmlAttributeChangedReport>();
     listener.AssertExpectedConflictCount(0);
 }

 public void XmlMergerCallsImmutableElementMergeServiceForImmutableElement()
 {
     var listener = new ListenerForUnitTests();
     var merger = new XmlMerger(new NullMergeSituation())
     {
         EventListener = listener
     };
     var elemStrat = new ElementStrategy(false)
         {
             IsImmutable = true
         };
     merger.MergeStrategies.SetStrategy("ImmutableElemment", elemStrat);
     var ancestor = CreateNode("<ImmutableElemment attr='originalvalue' />");
     var ours = CreateNode("<ImmutableElemment attr='ourvalue' />");
     var theirs = CreateNode("<ImmutableElemment attr='theirvalue' />");
     merger.MergeInner(ref ours, theirs, ancestor);
     Assert.AreSame(ancestor, ours);
     Assert.AreEqual("<ImmutableElemment attr=\"originalvalue\" />", ancestor.OuterXml);
     listener.AssertExpectedChangesCount(0);
     listener.AssertExpectedConflictCount(0);
 }

        private static XmlNode HandleCaseOfNoAncestor(XmlMerger merger, XmlNode ours, XmlNode theirs)
        {
            var mainNodeStrategy = merger.MergeStrategies.GetElementStrategy(ours ?? theirs);
            var mergeSituation = merger.MergeSituation;
            var pathToFileInRepository = mergeSituation.PathToFileInRepository;
            if (ours == null)
            {
                // They added, we did nothing.
            // Route tested, but the MergeChildrenMethod adds the change report for us.
                // So, theory has it one can't get here from any normal place.
                // But, keep it, in case MergeChildrenMethod gets 'fixed'.
                merger.EventListener.ChangeOccurred(new XmlAdditionChangeReport(pathToFileInRepository, theirs));
                return theirs;
            }
            if (theirs == null)
            {
                // We added, they did nothing.
            // Route tested.
                merger.EventListener.ChangeOccurred(new XmlAdditionChangeReport(pathToFileInRepository, ours));
                return ours;
            }

            // Both added the special containing node.
            // Remove children nodes to see if main containing nodes are the same.
            if (XmlUtilities.AreXmlElementsEqual(ours, theirs))
            {
            // Route tested.
                // Same content.
                merger.EventListener.ChangeOccurred(new XmlBothAddedSameChangeReport(pathToFileInRepository, ours));
            }
            else
            {
                // Different content.
                var ourChild = GetElementChildren(ours).FirstOrDefault();
                var theirChild = GetElementChildren(theirs).FirstOrDefault();
                var ourClone = MakeClone(ours);
                var theirClone = MakeClone(theirs);
                if (XmlUtilities.AreXmlElementsEqual(ourClone, theirClone))
                {
                    // new main elements are the same, but not the contained child
                    merger.EventListener.ChangeOccurred(new XmlBothAddedSameChangeReport(pathToFileInRepository, ourClone));
                    if (ourChild == null && theirChild == null)
                        return ours; // Nobody added the child node.
                    if (ourChild == null)
                    {
                        merger.EventListener.ChangeOccurred(new XmlAdditionChangeReport(pathToFileInRepository, theirChild));
                        ours.AppendChild(theirChild);
                        return ours;
                    }
                    if (theirChild == null)
                    {
                        merger.EventListener.ChangeOccurred(new XmlAdditionChangeReport(pathToFileInRepository, ourChild));
                        return ours;
                    }
                    // both children exist, but are different.
                    var mergeStrategyForChild = merger.MergeStrategies.GetElementStrategy(ourChild);
                    if (merger.MergeSituation.ConflictHandlingMode == MergeOrder.ConflictHandlingModeChoices.WeWin)
                    {
                        // Do the clone thing on the two child nodes to see if the diffs are in the child or lower down.
                        var ourChildClone = MakeClone(ourChild);
                        var theirChildClone = MakeClone(theirChild);
                        if (XmlUtilities.AreXmlElementsEqual(ourChildClone, theirChildClone))
                        {
                            var ourChildReplacement = ourChild;
                            merger.MergeInner(ours, ref ourChildReplacement, theirChild, null);
                            if (!ReferenceEquals(ourChild, ourChildReplacement))
                            {
                                XmlUtilities.ReplaceOursWithTheirs(ours, ref ourChild, ourChildReplacement);
                            }
                        }
                        else
                        {
                            merger.ConflictOccurred(new BothAddedMainElementButWithDifferentContentConflict(ourChild.Name, ourChild, theirChild,
                                                                                                            mergeSituation, mergeStrategyForChild,
                                                                                                            mergeSituation.AlphaUserId));
                        }
                    }
                    else
                    {
                        // Do the clone thing on the two child nodes to see if the diffs are in the child or lower down.
                        var ourChildClone = MakeClone(ourChild);
                        var theirChildClone = MakeClone(theirChild);
                        if (XmlUtilities.AreXmlElementsEqual(ourChildClone, theirChildClone))
                        {
                            var ourChildReplacement = ourChild;
                            merger.MergeInner(ours, ref ourChildReplacement, theirChild, null);
                            if (!ReferenceEquals(ourChild, ourChildReplacement))
                            {
                                XmlUtilities.ReplaceOursWithTheirs(ours, ref ourChild, ourChildReplacement);
                            }
                        }
                        else
                        {
                            merger.ConflictOccurred(new BothAddedMainElementButWithDifferentContentConflict(ourChild.Name, ourChild, theirChild,
                                                                                                            mergeSituation, mergeStrategyForChild,
                                                                                                            mergeSituation.AlphaUserId));
                            XmlUtilities.ReplaceOursWithTheirs(ours, ref ourChild, theirChild);
                        }
                    }
                    return ours;
//.........这里部分代码省略.........

        private static XmlNode Run(XmlMerger merger, XmlNode ours, XmlNode theirs, XmlNode ancestor)
        {
            if (ours == null && theirs == null && ancestor == null)
                return null;

            if (ancestor == null)
            {
                return HandleCaseOfNoAncestor(merger, ours, theirs);
            }
            // ancestor is not null at this point.
            var mergeSituation = merger.MergeSituation;
            var pathToFileInRepository = mergeSituation.PathToFileInRepository;
            if (ours == null && theirs == null)
            {
                // We both deleted main node.
            // Route tested, but the MergeChildrenMethod adds the change report for us.
                merger.EventListener.ChangeOccurred(new XmlBothDeletionChangeReport(pathToFileInRepository, ancestor));
                return null;
            }
            if (ours == null)
            {
                return HandleOursNotPresent(merger, ancestor, theirs);
            }
            if (theirs == null)
            {
                return HandleTheirsNotPresent(merger, ancestor, ours);
            }
            // End of checking main parent node.

            // ancestor, ours, and theirs all exist here.
            var ourChild = GetElementChildren(ours).FirstOrDefault();
            var theirChild = GetElementChildren(theirs).FirstOrDefault();
            var ancestorChild = GetElementChildren(ancestor).FirstOrDefault();
            if (ourChild == null && theirChild == null && ancestorChild == null)
            {
                return ours; // All three are childless.
            }

            if (ancestorChild == null)
            {
                return HandleCaseOfNoAncestorChild(merger, ours, ourChild, theirChild);
            }
            var mergeStrategyForChild = merger.MergeStrategies.GetElementStrategy(ancestorChild);
            if (ourChild == null)
            {
                return HandleOurChildNotPresent(merger, ours, ancestor, theirChild, pathToFileInRepository, ancestorChild, mergeSituation, mergeStrategyForChild);
            }
            if (theirChild == null)
            {
                return HandleTheirChildNotPresent(merger, ours, ancestor, ancestorChild, ourChild, mergeSituation, mergeStrategyForChild, pathToFileInRepository);
            }

            // ancestorChild, ourChild, and theirChild all exist.
            // But, it could be that we or they deleted and added something.
            // Check for edit vs delete+add, or there can be two items in ours, which is not legal.
            var match = mergeStrategyForChild.MergePartnerFinder.GetNodeToMerge(ourChild, ancestor, SetFromChildren.Get(ancestor));
            if (match == null)
            {
                // we deleted it and added a new one.
                if (XmlUtilities.AreXmlElementsEqual(theirChild, ancestorChild))
                {
                    // Our delete+add wins, since they did nothing.
                    merger.EventListener.ChangeOccurred(new XmlDeletionChangeReport(pathToFileInRepository, ancestor, ancestorChild));
                    merger.EventListener.ChangeOccurred(new XmlAdditionChangeReport(pathToFileInRepository, ourChild));
                    return ours;
                }

                // They edited old one, so they win over our delete+add.
                merger.ConflictOccurred(new RemovedVsEditedElementConflict(theirChild.Name, theirChild, null, ancestorChild,
                                                                           mergeSituation, mergeStrategyForChild,
                                                                           mergeSituation.BetaUserId));
                XmlUtilities.ReplaceOursWithTheirs(ours, ref ourChild, theirChild);
                return ours;
            }
            match = mergeStrategyForChild.MergePartnerFinder.GetNodeToMerge(theirChild, ancestor, SetFromChildren.Get(ancestor));
            if (match == null)
            {
                // they deleted it and added a new one.
                if (XmlUtilities.AreXmlElementsEqual(ourChild, ancestorChild))
                {
                    // Their delete+add wins, since we did nothing.
                    merger.EventListener.ChangeOccurred(new XmlDeletionChangeReport(pathToFileInRepository, ancestor, ancestorChild));
                    merger.EventListener.ChangeOccurred(new XmlAdditionChangeReport(pathToFileInRepository, theirChild));
                    XmlUtilities.ReplaceOursWithTheirs(ours, ref ourChild, theirChild);
                    return ours;
                }

                // We edited old one, so we win over their delete+add.
                merger.ConflictOccurred(new RemovedVsEditedElementConflict(ourChild.Name, ourChild, null, ancestorChild,
                                                                           mergeSituation, mergeStrategyForChild,
                                                                           mergeSituation.AlphaUserId));
                return ours;
            }
            merger.MergeInner(ours, ref ourChild, theirChild, ancestorChild);
            // Route tested. (UsingWith_NumberOfChildrenAllowed_ZeroOrOne_DoesNotThrowWhenParentHasOneChildNode)
            return ours;
        }

 private static XmlNode HandleCaseOfNoAncestorChild(XmlMerger merger, XmlNode ours, XmlNode ourChild, XmlNode theirChild)
 {
     var mergeSituation = merger.MergeSituation;
     var pathToFileInRepository = mergeSituation.PathToFileInRepository;
     var mergeStrategyForChild = merger.MergeStrategies.GetElementStrategy(ourChild ?? theirChild);
     if (ourChild == null)
     {
         // they added child.
         merger.EventListener.ChangeOccurred(new XmlAdditionChangeReport(pathToFileInRepository, theirChild));
         ours.AppendChild(theirChild);
         return ours;
     }
     if (theirChild == null)
     {
         // We added child.
         merger.EventListener.ChangeOccurred(new XmlAdditionChangeReport(pathToFileInRepository, ourChild));
         return ours;
     }
     // Both added child.
     if (XmlUtilities.AreXmlElementsEqual(ourChild, theirChild))
     {
         // Both are the same.
         merger.EventListener.ChangeOccurred(new XmlBothAddedSameChangeReport(pathToFileInRepository, ourChild));
         return ours;
     }
     // Both are different.
     if (XmlUtilities.IsTextLevel(ourChild, theirChild, null))
     {
         if (merger.MergeSituation.ConflictHandlingMode == MergeOrder.ConflictHandlingModeChoices.WeWin)
         {
             merger.ConflictOccurred(new XmlTextBothAddedTextConflict(ourChild.Name, ourChild, theirChild, mergeSituation,
                                                                      mergeStrategyForChild, mergeSituation.AlphaUserId));
         }
         else
         {
             merger.ConflictOccurred(new XmlTextBothAddedTextConflict(theirChild.Name, theirChild, ourChild, mergeSituation,
                                                                      mergeStrategyForChild, mergeSituation.BetaUserId));
             XmlUtilities.ReplaceOursWithTheirs(ours, ref ourChild, theirChild);
         }
     }
     else
     {
         if (merger.MergeSituation.ConflictHandlingMode == MergeOrder.ConflictHandlingModeChoices.WeWin)
         {
             var ourChildClone = MakeClone(ourChild);
             var theirChildClone = MakeClone(theirChild);
             if (XmlUtilities.AreXmlElementsEqual(ourChildClone, theirChildClone))
             {
                 merger.EventListener.ChangeOccurred(new XmlAdditionChangeReport(pathToFileInRepository, ourChild));
                 var ourChildReplacement = ourChild;
                 merger.MergeInner(ours, ref ourChildReplacement, theirChild, null);
                 if (!ReferenceEquals(ourChild, ourChildReplacement))
                 {
                     XmlUtilities.ReplaceOursWithTheirs(ours, ref ourChild, ourChildReplacement);
                 }
             }
             else
             {
                 merger.ConflictOccurred(new BothAddedMainElementButWithDifferentContentConflict(ourChild.Name, ourChild, theirChild,
                                                                                                 mergeSituation, mergeStrategyForChild,
                                                                                                 mergeSituation.AlphaUserId));
             }
         }
         else
         {
             var ourChildClone = MakeClone(ourChild);
             var theirChildClone = MakeClone(theirChild);
             if (XmlUtilities.AreXmlElementsEqual(ourChildClone, theirChildClone))
             {
                 merger.EventListener.ChangeOccurred(new XmlAdditionChangeReport(pathToFileInRepository, theirChild));
                 var ourChildReplacement = ourChild;
                 merger.MergeInner(ours, ref ourChildReplacement, theirChild, null);
                 if (!ReferenceEquals(ourChild, ourChildReplacement))
                 {
                     XmlUtilities.ReplaceOursWithTheirs(ours, ref ourChild, ourChildReplacement);
                 }
             }
             else
             {
                 merger.ConflictOccurred(new BothAddedMainElementButWithDifferentContentConflict(theirChild.Name, theirChild, ourChild,
                                                                                                 mergeSituation, mergeStrategyForChild,
                                                                                                 mergeSituation.BetaUserId));
                 XmlUtilities.ReplaceOursWithTheirs(ours, ref ourChild, theirChild);
             }
         }
     }
     return ours;
 }

        private static XmlNode Run(XmlMerger merger, XmlNode ours, XmlNode theirs, XmlNode ancestor)
        {
            if (ours == null && theirs == null && ancestor == null)
                return null;

            var ourChild = GetElementChildren(ours).FirstOrDefault();
            var theirChild = GetElementChildren(theirs).FirstOrDefault();
            var ancestorChild = GetElementChildren(ancestor).FirstOrDefault();
            XmlNode ourReplacementChild;
            if (ancestor == null)
            {
                if (ours == null)
                {
                    // They added, we did nothing.
            // Route tested, but the MergeChildrenMethod adds the change report for us.
                    // So, theory has it one can't get here from any normal place.
                    // But, keep it, in case MergeChildrenMethod gets 'fixed'.
                    merger.EventListener.ChangeOccurred(new XmlAdditionChangeReport(merger.MergeSituation.PathToFileInRepository, theirs));
                    return theirs;
                }
                if (theirs == null)
                {
                    // We added, they did nothing.
            // Route tested.
                    merger.EventListener.ChangeOccurred(new XmlAdditionChangeReport(merger.MergeSituation.PathToFileInRepository, ours));
                    return ours;
                }

                // Both added the special containing node.
            // Route tested.
                merger.EventListener.ChangeOccurred(new XmlBothAddedSameChangeReport(merger.MergeSituation.PathToFileInRepository, ours));

                if (ourChild == null && theirChild == null && ancestorChild == null)
                    return null; // Route tested.

                if (ourChild == null && theirChild != null)
                {
            // Route tested.
                    merger.EventListener.ChangeOccurred(new XmlAdditionChangeReport(merger.MergeSituation.PathToFileInRepository, theirChild));
                    ours.AppendChild(theirChild);
                    return ours;
                }
                if (theirChild == null)
                {
            // Route tested.
                    merger.EventListener.ChangeOccurred(new XmlAdditionChangeReport(merger.MergeSituation.PathToFileInRepository, ourChild));
                    return ours;
                }

                // Both ourChild and theirChild exist, and may or may not be the same.
                var mergeStrategy = merger.MergeStrategies.GetElementStrategy(ourChild);
                var match = mergeStrategy.MergePartnerFinder.GetNodeToMerge(ourChild, theirs, SetFromChildren.Get(theirs));
                if (match == null)
                {
                    XmlNode winner;
                    string winnerId;
                    XmlNode loser;
                    // Work up conflict report (for both we and they win options), since the users didn't add the same thing.
                    if (merger.MergeSituation.ConflictHandlingMode == MergeOrder.ConflictHandlingModeChoices.WeWin)
                    {
                        winner = ourChild;
                        winnerId = merger.MergeSituation.AlphaUserId;
                        loser = theirChild;
                    }
                    else
                    {
                        winner = theirChild;
                        winnerId = merger.MergeSituation.BetaUserId;
                        loser = ourChild;
                        ours = theirs;
                    }
            // Route tested.
                    merger.ConflictOccurred(new BothAddedMainElementButWithDifferentContentConflict(winner.Name, winner, loser, merger.MergeSituation, mergeStrategy, winnerId));
                    return ours;
                }

                // Matched nodes, as far as that goes. But, are they the same or not?
                if (XmlUtilities.AreXmlElementsEqual(ourChild, theirChild))
                {
                    // Both added the same thing.
            // Route tested.
                    merger.EventListener.ChangeOccurred(new XmlBothAddedSameChangeReport(merger.MergeSituation.PathToFileInRepository, ourChild));
                    return ours;
                }

                // Move on down and merge them.
                // Both messed with the inner stuff, but not the same way.
            // Route tested.
                ourReplacementChild = ourChild;
                merger.MergeInner(ref ourReplacementChild, theirChild, ancestorChild);
                if (!ReferenceEquals(ourChild, ourReplacementChild))
                    ours.ReplaceChild(ours.OwnerDocument.ImportNode(ourReplacementChild, true), ourChild);

                return ours;
            }

            // ancestor is not null at this point.
            // Check the inner nodes
            if (ours == null && theirs == null)
            {
//.........这里部分代码省略.........