C# 用C合并并覆盖.NET配置文件#

我编写这段代码是为了合并两个.NET配置文件：添加不存在的节点并覆盖现有节点上的值。 我避免使用速度更快的读写器方式，因为我使用它的应用程序对性能并不重要。你觉得这个怎么样

using System;
using System.Xml;

namespace devcoach.FrameworkExtensions
{
    /// <summary>
    /// Extension methods for the type 
    /// <see cref="System.Xml.XmlDocument"/>.
    /// </summary>
    public static class XmlDocumentExtensions
    {
        /// <summary>
        /// Merges the specified instance.
        /// </summary>
        /// <param name="instance">The instance.</param>
        /// <param name="mergeDoc">The merge doc.</param>
        public static void Merge(
            this XmlDocument instance,
            XmlDocument mergeDoc)
        {
            var mergeRoot = mergeDoc.DocumentElement;
            var sourceRoot = instance.DocumentElement;
            if (sourceRoot == null) return;
            instance.Merge(sourceRoot, mergeRoot, false);
        }

        /// <summary>
        /// Merges the specified instance.
        /// </summary>
        /// <param name="instance">The instance.</param>
        /// <param name="mergeDoc">The merge doc.</param>
        /// <param name="isNetConfigFile">if set to <c>true</c> if documents 
        /// are .net config files.</param>
        public static void Merge(
            this XmlDocument instance,
            XmlDocument mergeDoc,
            bool isNetConfigFile)
        {
            var mergeRoot = mergeDoc.DocumentElement;
            var sourceRoot = instance.DocumentElement;
            if (sourceRoot == null) return;
            instance.Merge(sourceRoot, mergeRoot, true);
        }

        /// <summary>
        /// Merges the specified source doc.
        /// </summary>
        /// <param name="sourceDoc">The source doc.</param>
        /// <param name="sourceRoot">The source root.</param>
        /// <param name="mergeRoot">The merge root.</param>
        public static void Merge(
            this XmlDocument sourceDoc,
            XmlNode sourceRoot,
            XmlNode mergeRoot)
        {
            sourceDoc.Merge(
                sourceRoot,
                mergeRoot,
                false);
        }

        /// <summary>
        /// Merges the specified source doc.
        /// </summary>
        /// <param name="sourceDoc">The source doc.</param>
        /// <param name="sourceRoot">The source root.</param>
        /// <param name="mergeRoot">The merge root.</param>
        /// <param name="isNetConfigFile">if set to <c>true</c> if documents 
        /// are .net config files.</param>
        public static void Merge(
            this XmlDocument sourceDoc,
            XmlNode sourceRoot,
            XmlNode mergeRoot,
            bool isNetConfigFile)
        {
            #region Check parameters and if needed throw ArgumentNullException
            if (sourceDoc == null)
            {
                throw new ArgumentNullException("sourceDoc");
            }
            if (sourceRoot == null)
            {
                throw new ArgumentNullException("sourceRoot");
            }
            if (mergeRoot == null)
            {
                throw new ArgumentNullException("mergeRoot");
            }
            #endregion

            if (!string.IsNullOrEmpty(mergeRoot.InnerText))
            {
                sourceRoot.InnerText = mergeRoot.InnerText;
            }
            if (!string.IsNullOrEmpty(mergeRoot.Value))
            {
                sourceRoot.Value = mergeRoot.Value;
            }

            #region Copy attributes...
            var mergeRootAttributes = mergeRoot.Attributes;
            if (mergeRootAttributes != null)
            {
                var mergeRootAttributesCount = mergeRootAttributes.Count;

                for (var k = 0; k < mergeRootAttributesCount; k++)
                {
                    var mergeAttribute = mergeRootAttributes[k];
                    var mergeAttributeName = mergeAttribute.LocalName;

                    var sourceAttribute =
                        sourceRoot.Attributes[mergeAttributeName]
                        ?? sourceRoot.Attributes.Append(
                             sourceDoc.CreateAttribute(
                                 mergeAttribute.Prefix,
                                 mergeAttribute.LocalName,
                                 mergeAttribute.NamespaceURI));

                    sourceAttribute.Value = mergeAttribute.Value;
                }
            }
            #endregion

            // loop child nodes...
            var mergeRootNodesCount = mergeRoot.ChildNodes.Count;
            for (var i = 0; i < mergeRootNodesCount; i++)
            {
                XmlNode foundNode = null;
                var mergeNode = mergeRoot.ChildNodes[i];
                var mergeNodeName = mergeNode.LocalName;
                var sourceRootNodeCount = sourceRoot.ChildNodes.Count;

                #region Find node in source...
                for (var j = 0; j < sourceRootNodeCount; j++)
                {
                    var sourceNode = sourceRoot.ChildNodes[j];
                    var sourceNodeName = sourceNode.LocalName;

                    if ((isNetConfigFile &&
                            mergeNodeName == "section" ||
                            mergeNodeName == "sectionGroup"
                        ) ||
                        sourceNodeName != mergeNodeName) continue;

                    foundNode = sourceNode;
                    break;
                }
                #endregion

                #region create a new node...
                if (foundNode == null)
                {
                    foundNode =
                        sourceRoot.AppendChild(
                         sourceDoc.CreateNode(
                            mergeNode.NodeType,
                            mergeNode.Prefix,
                            mergeNode.LocalName,
                            mergeNode.NamespaceURI));
                }
                #endregion

                sourceDoc.Merge(foundNode, mergeNode);
            }
        }
    }
}

使用系统；
使用System.Xml；
命名空间devcoach.FrameworkExtensions
{
/// 
///类型的扩展方法
/// .
/// 
公共静态类XmlDocumentExtensions
{
/// 
///合并指定的实例。
/// 
///实例。
///合并文档。
公共静态无效合并(
这个XmlDocument实例，
XmlDocument（doc）
{
var mergeRoot=mergeDoc.DocumentElement；
var sourceRoot=instance.DocumentElement；
if（sourceRoot==null）返回；
Merge（sourceRoot、mergeRoot、false）；
}
/// 
///合并指定的实例。
/// 
///实例。
///合并文档。
///如果将文档设置为true，则
///是.net配置文件。
公共静态无效合并(
这个XmlDocument实例，
xmldocumentmergedoc，
bool isNetConfigFile）
{
var mergeRoot=mergeDoc.DocumentElement；
var sourceRoot=instance.DocumentElement；
if（sourceRoot==null）返回；
Merge（sourceRoot，mergeRoot，true）；
}
/// 
///合并指定的源文档。
/// 
///源文档。
///源根。
///合并根目录。
公共静态无效合并(
此XmlDocument sourceDoc，
XmlNode sourceRoot，
XmlNode（根节点）
{
sourceDoc.Merge(
sourceRoot，
合并根，
假）；
}
/// 
///合并指定的源文档。
/// 
///源文档。
///源根。
///合并根目录。
///如果将文档设置为true，则
///是.net配置文件。
公共静态无效合并(
此XmlDocument sourceDoc，
XmlNode sourceRoot，
XmlNode合并根，
bool isNetConfigFile）
{
#区域检查参数，如果需要，抛出ArgumentNullException
if（sourceDoc==null）
{
抛出新ArgumentNullException（“sourceDoc”）；
}
if（sourceRoot==null）
{
抛出新ArgumentNullException（“sourceRoot”）；
}
if（mergeRoot==null）
{
抛出新ArgumentNullException（“mergeRoot”）；
}
#端区
如果（！string.IsNullOrEmpty（mergeRoot.InnerText））
{
sourceRoot.InnerText=mergeRoot.InnerText；
}
如果（！string.IsNullOrEmpty（mergeRoot.Value））
{
sourceRoot.Value=mergeRoot.Value；
}
#区域复制属性。。。
var mergeRootAttributes=mergeRoot.Attributes；
if（mergeRootAttributes！=null）
{
var mergeRootAttributesCount=mergeRootAttributes.Count；
for（var k=0；k

如果它适合你

---

您应该看看Linq到XML。它比System.XML好得多：代码更干净，更容易编写代码，更容易理解代码，代码更少。很好。

您还可以查看XmlMassUpdate任务，它可以做同样的事情