C# XDocument.GetOrCreateElement方法代码示例

 private XElement GetOrCreateRootElem(XDocument document, string rootElementName)
 {
     var rootElement = document.Element(rootElementName);
     if (rootElement == null)
     {
         if (document.Root != null)
             rootElement = document.Root.GetOrCreateElement(rootElementName);
         else
             rootElement = document.GetOrCreateElement(rootElementName);
     }
     return rootElement;
 }

        // <summary>
        // Checks whether or not the given XML document representing a .config file contains
        // an EntityFramework "defaultConnectionFactory" entry or not. If no entry is found then one
        // is added for the given connection factory specification.
        // </summary>
        // <param name="config"> An XML document representing the config file. </param>
        // <param name="specification"> Specifies the connection factory and constructor arguments to use. </param>
        // <returns> True if the document was modified; false if no change was made. </returns>
        public virtual bool AddConnectionFactoryToConfig(XDocument config, ConnectionFactorySpecification specification)
        {
            DebugCheck.NotNull(config);
            DebugCheck.NotNull(specification);

            var entityFramework = config
                .GetOrCreateElement(ConfigurationElementName)
                .GetOrCreateElement(EntityFrameworkElementName);

            if (entityFramework.Elements(DefaultConnectionFactoryElementName).Any())
            {
                return false;
            }

            var factoryElement = entityFramework
                .GetOrCreateElement(
                    DefaultConnectionFactoryElementName,
                    new XAttribute("type", specification.ConnectionFactoryName));

            AddFactoryArguments(factoryElement, specification);

            return true;
        }

        /// <summary>
        /// Sets the EntityFramework "defaultConnectionFactory" in the given XML document representing a
        /// .config file to use th given specification. This method differs from AddConnectionFactoryToConfig
        /// in that it always sets the entry to use the given specification even if it was already present
        /// and set to something else.
        /// </summary>
        /// <param name="config"> An XML document representing the config file.</param>
        /// <param name="specification"> Specifies the connection factory and constructor arguments to use.</param>
        /// <returns>True if the document was modified; false if no change was made.</returns>
        public virtual bool AddOrUpdateConnectionFactoryInConfig(XDocument config, ConnectionFactorySpecification specification)
        {
            Contract.Requires(config != null);

            var connectionFactoryElement = config
                .GetOrCreateElement(ConfigurationElementName)
                .GetOrCreateElement(EntityFrameworkElementName)
                .GetOrCreateElement(DefaultConnectionFactoryElementName);

            var currentFactoryAttribute = connectionFactoryElement.Attribute("type");
            if (currentFactoryAttribute != null
                && specification.ConnectionFactoryName.Equals(currentFactoryAttribute.Value, StringComparison.OrdinalIgnoreCase))
            {
                return false;
            }

            connectionFactoryElement.RemoveAll();
            connectionFactoryElement.Add(new XAttribute("type", specification.ConnectionFactoryName));

            AddFactoryArguments(connectionFactoryElement, specification);

            return true;
        }

        // <summary>
        // Ensures that the config file has a defined "entityFramework" section and that it references
        // the current version of the EntityFramework.dll assembly.
        // </summary>
        // <param name="config"> An XML document representing the config file. </param>
        // <param name="entityFrameworkVersion"> The version of EntityFramework.dll to use. </param>
        // <returns> True if the document was modified; false if no change was made. </returns>
        public virtual bool AddOrUpdateConfigSection(XDocument config, Version entityFrameworkVersion)
        {
            DebugCheck.NotNull(config);
            DebugCheck.NotNull(entityFrameworkVersion);

            var configSections = config
                .GetOrCreateElement(ConfigurationElementName)
                .GetOrCreateElement(ConfigSectionsElementName);

            var typeAttribute = configSections
                .Elements(SectionElementName)
                .Where(e => (string)e.Attribute("name") == EntityFrameworkElementName)
                .SelectMany(e => e.Attributes("type"))
                .FirstOrDefault();

            // Hard coding this so that we don't need to load EntityFramework.dll to get it.
            const string entityFrameworkSectionName =
                "System.Data.Entity.Internal.ConfigFile.EntityFrameworkSection, EntityFramework, Version={0}, Culture=neutral, PublicKeyToken=b77a5c561934e089";

            var efSectionTypeName = string.Format(
                CultureInfo.InvariantCulture, entityFrameworkSectionName,
                entityFrameworkVersion);

            if (typeAttribute != null)
            {
                var sectionElement = typeAttribute.Parent;
                var requirePermissionAttribute = sectionElement.Attribute("requirePermission");

                if (efSectionTypeName.Equals(typeAttribute.Value, StringComparison.InvariantCultureIgnoreCase)
                    && requirePermissionAttribute != null)
                {
                    return false;
                }

                typeAttribute.Value = efSectionTypeName;

                if (requirePermissionAttribute == null)
                {
                    sectionElement.Add(new XAttribute("requirePermission", false));
                }
            }
            else
            {
                configSections.Add(
                    new XElement(
                        SectionElementName, new XAttribute("name", EntityFrameworkElementName),
                        new XAttribute("type", efSectionTypeName), new XAttribute("requirePermission", false)));
            }

            return true;
        }

        public virtual bool AddProviderToConfig(XDocument config, string invariantName, string typeName)
        {
            DebugCheck.NotNull(config);

            var providersElement = config
                .GetOrCreateElement(ConfigurationElementName)
                .GetOrCreateElement(EntityFrameworkElementName)
                .GetOrCreateElement(ProvidersElementName);

            var invariantAttribute = new XAttribute("invariantName", invariantName);
            var modificationMade = false;

            // Check if element exists at end
            var providerElement = providersElement.Elements(ProviderElementName).LastOrDefault();
            if (providerElement == null
                || providerElement.Attributes(invariantAttribute.Name).All(a => a.Value != invariantAttribute.Value))
            {
                // Check if element exists and if so move it to end
                providerElement = providersElement
                    .Elements(ProviderElementName)
                    .FirstOrDefault(e => e.Attributes(invariantAttribute.Name).Any(a => a.Value == invariantAttribute.Value));

                if (providerElement != null)
                {
                    providerElement.Remove();
                }
                else
                {
                    providerElement = new XElement(ProviderElementName, invariantAttribute);
                }

                providersElement.Add(providerElement);
                modificationMade = true;
            }

            var currentTypeAttribute = providerElement.Attribute("type");
            if (currentTypeAttribute == null)
            {
                providerElement.Add(new XAttribute("type", typeName));
                modificationMade = true;
            }
            else if (!typeName.Equals(currentTypeAttribute.Value, StringComparison.OrdinalIgnoreCase))
            {
                currentTypeAttribute.Value = typeName;
                modificationMade = true;
            }

            return modificationMade;
        }