// parentConfig contains the config that we'd merge with.
        override protected object CreateSection(bool inputIsTrusted, FactoryRecord factoryRecord, SectionRecord sectionRecord, object parentConfig, ConfigXmlReader reader) {
            // Get the factory used to create a section.
            RuntimeConfigurationFactory factory = (RuntimeConfigurationFactory) factoryRecord.Factory;

            // Use the factory to create a section.
            object config = factory.CreateSection(inputIsTrusted, this, factoryRecord, sectionRecord, parentConfig, reader);

            return config;
        }

 internal void AddConfigurationSection(string group, string name, ConfigurationSection configSection)
 {
     if (base.IsLocationConfig)
     {
         throw new InvalidOperationException(System.Configuration.SR.GetString("Config_add_configurationsection_in_location_config"));
     }
     BaseConfigurationRecord.VerifySectionName(name, null, false);
     if (configSection == null)
     {
         throw new ArgumentNullException("configSection");
     }
     if (configSection.SectionInformation.Attached)
     {
         throw new InvalidOperationException(System.Configuration.SR.GetString("Config_add_configurationsection_already_added"));
     }
     string configKey = BaseConfigurationRecord.CombineConfigKey(group, name);
     if (base.FindFactoryRecord(configKey, true) != null)
     {
         throw new ArgumentException(System.Configuration.SR.GetString("Config_add_configurationsection_already_exists"));
     }
     if (!string.IsNullOrEmpty(configSection.SectionInformation.ConfigSource))
     {
         this.ChangeConfigSource(configSection.SectionInformation, null, null, configSection.SectionInformation.ConfigSource);
     }
     if (this._sectionFactories != null)
     {
         this._sectionFactories.Add(configKey, new FactoryId(configKey, group, name));
     }
     string type = configSection.SectionInformation.Type;
     if (type == null)
     {
         type = base.Host.GetConfigTypeName(configSection.GetType());
     }
     FactoryRecord factoryRecord = new FactoryRecord(configKey, group, name, type, configSection.SectionInformation.AllowLocation, configSection.SectionInformation.AllowDefinition, configSection.SectionInformation.AllowExeDefinition, configSection.SectionInformation.OverrideModeDefaultSetting, configSection.SectionInformation.RestartOnExternalChanges, configSection.SectionInformation.RequirePermission, this._flags[0x2000], false, base.ConfigStreamInfo.StreamName, -1) {
         Factory = System.Configuration.TypeUtil.GetConstructorWithReflectionPermission(configSection.GetType(), typeof(ConfigurationSection), true),
         IsFactoryTrustedWithoutAptca = System.Configuration.TypeUtil.IsTypeFromTrustedAssemblyWithoutAptca(configSection.GetType())
     };
     base.EnsureFactories()[configKey] = factoryRecord;
     SectionRecord sectionRecord = base.EnsureSectionRecordUnsafe(configKey, false);
     sectionRecord.Result = configSection;
     sectionRecord.ResultRuntimeObject = configSection;
     if (this._removedSections != null)
     {
         this._removedSections.Remove(configKey);
     }
     configSection.SectionInformation.AttachToConfigurationRecord(this, factoryRecord, sectionRecord);
     string rawXml = configSection.SectionInformation.RawXml;
     if (!string.IsNullOrEmpty(rawXml))
     {
         configSection.SectionInformation.RawXml = null;
         configSection.SectionInformation.SetRawXml(rawXml);
     }
 }

        internal void AttachToConfigurationRecord(MgmtConfigurationRecord configRecord, FactoryRecord factoryRecord) {
            _configRecord = configRecord;
            _configKey = factoryRecord.ConfigKey;
            _group = factoryRecord.Group;
            _name = factoryRecord.Name;
            _typeName = factoryRecord.FactoryTypeName;

            if (_typeName != null) {
                 FactoryRecord parentFactoryRecord = null;
                 if (!configRecord.Parent.IsRootConfig) {
                     parentFactoryRecord = configRecord.Parent.FindFactoryRecord(factoryRecord.ConfigKey, true);
                 }

                 _declarationRequired = (parentFactoryRecord == null || parentFactoryRecord.FactoryTypeName == null);
                 _declared            = configRecord.GetFactoryRecord(factoryRecord.ConfigKey, true) != null;
            }
        }

 internal void AttachToConfigurationRecord(MgmtConfigurationRecord configRecord, FactoryRecord factoryRecord)
 {
     this._configRecord = configRecord;
     this._configKey = factoryRecord.ConfigKey;
     this._group = factoryRecord.Group;
     this._name = factoryRecord.Name;
     this._typeName = factoryRecord.FactoryTypeName;
     if (this._typeName != null)
     {
         FactoryRecord record = null;
         if (!configRecord.Parent.IsRootConfig)
         {
             record = configRecord.Parent.FindFactoryRecord(factoryRecord.ConfigKey, true);
         }
         this._declarationRequired = (record == null) || (record.FactoryTypeName == null);
         this._declared = configRecord.GetFactoryRecord(factoryRecord.ConfigKey, true) != null;
     }
 }

 internal RuntimeConfigurationFactory(RuntimeConfigurationRecord configRecord, FactoryRecord factoryRecord)
 {
     Init(configRecord, factoryRecord);
 }

        internal void SetRuntimeConfigurationInformation(BaseConfigurationRecord configRecord, FactoryRecord factoryRecord, SectionRecord sectionRecord) {
            _flags[ Flag_Attached ] = true;

            // factory info
            _configKey          = factoryRecord.ConfigKey;
            _group              = factoryRecord.Group;
            _name               = factoryRecord.Name;
            _typeName           = factoryRecord.FactoryTypeName;
            _allowDefinition    = factoryRecord.AllowDefinition;
            _allowExeDefinition = factoryRecord.AllowExeDefinition;
            _flags[ Flag_AllowLocation            ] = factoryRecord.AllowLocation;
            _flags[ Flag_RestartOnExternalChanges ] = factoryRecord.RestartOnExternalChanges;
            _flags[ Flag_RequirePermission        ] = factoryRecord.RequirePermission;

            if (factoryRecord.IsUndeclared) {
                _flags[ Flag_IsUndeclared             ] = true;
                _flags[ Flag_Declared                 ] = false;
                _flags[ Flag_DeclarationRequired      ] = false;
            }
            else {
                _flags[ Flag_IsUndeclared             ] = false;
                _flags[ Flag_Declared                 ] = configRecord.GetFactoryRecord(factoryRecord.ConfigKey, false) != null;
                _flags[ Flag_DeclarationRequired      ] = configRecord.IsRootDeclaration(factoryRecord.ConfigKey, false);
            }

            // section info
            _flags[ Flag_LocationLocked ]           = sectionRecord.Locked;

            if (sectionRecord.HasFileInput) {
                SectionInput fileInput = sectionRecord.FileInput;

                _flags[ Flag_ProtectionProviderDetermined ] = fileInput.IsProtectionProviderDetermined;
                _protectionProvider                         = fileInput.ProtectionProvider;
                
                SectionXmlInfo sectionXmlInfo = fileInput.SectionXmlInfo;

                _configSource                       = sectionXmlInfo.ConfigSource;
                _configSourceStreamName             = sectionXmlInfo.ConfigSourceStreamName;
                _flags[ Flag_AllowOverride ]        = !sectionXmlInfo.LockChildren;
                _flags[ Flag_InheritInChildApps ]   = !sectionXmlInfo.SkipInChildApps;
                _protectionProviderName             = sectionXmlInfo.ProtectionProviderName;
            }
            else {
                _flags[ Flag_ProtectionProviderDetermined ] = false;
                _protectionProvider = null;
            }

            // element context information
            _configurationSection.AssociateContext( configRecord );
        }

        private ConstructorInfo CreateSectionGroupFactory(FactoryRecord factoryRecord)
        {
            Type type = string.IsNullOrEmpty(factoryRecord.FactoryTypeName)
                ? typeof(ConfigurationSectionGroup)
                : TypeUtil.GetType(Host, factoryRecord.FactoryTypeName, true);

            ConstructorInfo ctor = TypeUtil.GetConstructor(type,
                typeof(ConfigurationSectionGroup), true);

            return ctor;
        }

 // Create the factory that will evaluate configuration 
 override protected object CreateSectionFactory(FactoryRecord factoryRecord) {
     return new RuntimeConfigurationFactory(this, factoryRecord);
 }

            private object CreateSectionWithRestrictedPermissions(
                    RuntimeConfigurationRecord configRecord, FactoryRecord factoryRecord, SectionRecord sectionRecord, 
                    object parentConfig, ConfigXmlReader reader) {

                // run configuration section handlers as if user code was on the stack
                bool revertPermitOnly = false;
                try {
                    PermissionSet permissionSet = configRecord.GetRestrictedPermissions();
                    if (permissionSet != null) {
                        permissionSet.PermitOnly();
                        revertPermitOnly = true;
                    }

                    return CreateSectionImpl(configRecord, factoryRecord, sectionRecord, parentConfig, reader);
                }
                finally {
                    if (revertPermitOnly) {
                        CodeAccessPermission.RevertPermitOnly();
                    }
                }
            }

            private object CreateSectionImpl(
                    RuntimeConfigurationRecord configRecord, FactoryRecord factoryRecord, SectionRecord sectionRecord, 
                    object parentConfig, ConfigXmlReader reader) {

                object config;

                if (_sectionCtor != null) {
                    ConfigurationSection configSection = (ConfigurationSection) TypeUtil.InvokeCtorWithReflectionPermission(_sectionCtor);

                    configSection.SectionInformation.SetRuntimeConfigurationInformation(configRecord, factoryRecord, sectionRecord);

                    configSection.CallInit();

                    ConfigurationSection parentSection = (ConfigurationSection) parentConfig;
                    configSection.Reset(parentSection);

                    if (reader != null) {
                        configSection.DeserializeSection(reader);
                    }

                    // throw if there are any cached errors
                    ConfigurationErrorsException errors = configSection.GetErrors();
                    if (errors != null) {
                        throw errors;
                    }

                    // don't allow changes to sections at runtime
                    configSection.SetReadOnly();

                    // reset the modified bit
                    configSection.ResetModified();

                    config = configSection;
                }
                else {
                    if (reader != null) {
                        XmlNode xmlNode = ErrorInfoXmlDocument.CreateSectionXmlNode(reader);

                        CheckForLockAttributes(factoryRecord.ConfigKey, xmlNode);

                        // In v1, our old section handler expects a context that contains the virtualPath from the configPath
                        object configContext = configRecord.Host.CreateDeprecatedConfigContext(configRecord.ConfigPath);

                        config = _sectionHandler.Create(parentConfig, configContext, xmlNode);
                    }
                    else {
                        config = null;
                    }
                }

                return config;
            }

 private void InitWithFullTrust(RuntimeConfigurationRecord configRecord, FactoryRecord factoryRecord) {
     Init(configRecord, factoryRecord);
 }

        private string GetUpdatedSectionGroupDeclarationXml(FactoryRecord factoryRecord, ConfigurationSectionGroup configSectionGroup) {
            if (TargetFramework != null && !configSectionGroup.ShouldSerializeSectionGroupInTargetVersion(TargetFramework))
                return null;

            StringBuilder sb = new StringBuilder();
            sb.Append('<');
            sb.Append(KEYWORD_SECTIONGROUP);
            sb.Append(' ');
            AppendAttribute(sb, KEYWORD_SECTIONGROUP_NAME, configSectionGroup.Name);
            string type = (configSectionGroup.Type != null) ? configSectionGroup.Type : factoryRecord.FactoryTypeName;
            if (TypeStringTransformerIsSet)
                type = TypeStringTransformer(type);

            AppendAttribute(sb, KEYWORD_SECTIONGROUP_TYPE, type);

            sb.Append('>');

            return sb.ToString();
        }

        private string GetUpdatedSectionDeclarationXml(FactoryRecord factoryRecord, ConfigurationSection configSection, ConfigurationSaveMode saveMode) {
            StringBuilder sb = new StringBuilder();
            sb.Append('<');
            sb.Append(KEYWORD_SECTION);
            sb.Append(' ');
            string type = (configSection.SectionInformation.Type != null) ? configSection.SectionInformation.Type : factoryRecord.FactoryTypeName;
            if (TypeStringTransformerIsSet)
                type = TypeStringTransformer(type);

            AppendAttribute(sb, KEYWORD_SECTION_NAME, configSection.SectionInformation.Name);
            AppendAttribute(sb, KEYWORD_SECTION_TYPE, type);

            if ( !configSection.SectionInformation.AllowLocation ||
                 (saveMode == ConfigurationSaveMode.Full)        ||
                 ((saveMode == ConfigurationSaveMode.Modified) &&
                   configSection.SectionInformation.AllowLocationModified)) {
                AppendAttribute(sb,
                                KEYWORD_SECTION_ALLOWLOCATION,
                                configSection.SectionInformation.AllowLocation ?
                                    KEYWORD_TRUE :
                                    KEYWORD_FALSE);
            }

            if ((configSection.SectionInformation.AllowDefinition != ConfigurationAllowDefinition.Everywhere) ||
                    (saveMode == ConfigurationSaveMode.Full) ||
                    (saveMode == ConfigurationSaveMode.Modified  && configSection.SectionInformation.AllowDefinitionModified)) {

                string v = null;
                switch (configSection.SectionInformation.AllowDefinition) {
                    case ConfigurationAllowDefinition.Everywhere:
                        v = KEYWORD_SECTION_ALLOWDEFINITION_EVERYWHERE;
                        break;
                    case ConfigurationAllowDefinition.MachineOnly:
                        v = KEYWORD_SECTION_ALLOWDEFINITION_MACHINEONLY;
                        break;

                    case ConfigurationAllowDefinition.MachineToWebRoot:
                        v = KEYWORD_SECTION_ALLOWDEFINITION_MACHINETOWEBROOT;
                        break;

                    case ConfigurationAllowDefinition.MachineToApplication:
                        v = KEYWORD_SECTION_ALLOWDEFINITION_MACHINETOAPPLICATION;
                        break;
                }

                AppendAttribute(sb, KEYWORD_SECTION_ALLOWDEFINITION, v);
            }

            if ((configSection.SectionInformation.AllowExeDefinition !=
                    ConfigurationAllowExeDefinition.MachineToApplication ) ||
                    (saveMode == ConfigurationSaveMode.Full) ||
                    (saveMode == ConfigurationSaveMode.Modified  && configSection.SectionInformation.AllowExeDefinitionModified)) {

                AppendAttribute( sb,
                        KEYWORD_SECTION_ALLOWEXEDEFINITION,
                        ExeDefinitionToString(
                        configSection.SectionInformation.AllowExeDefinition )
                        );
            }

            if (    (configSection.SectionInformation.OverrideModeDefaultSetting.IsDefaultForSection == false) ||
                    (saveMode == ConfigurationSaveMode.Full) ||
                    (saveMode == ConfigurationSaveMode.Modified  && configSection.SectionInformation.OverrideModeDefaultModified)) {

                AppendAttribute(    sb,
                                    KEYWORD_SECTION_OVERRIDEMODEDEFAULT,
                                    configSection.SectionInformation.OverrideModeDefaultSetting.OverrideModeXmlValue);
            }

            if (!configSection.SectionInformation.RestartOnExternalChanges) {
                AppendAttribute(sb, KEYWORD_SECTION_RESTARTONEXTERNALCHANGES, KEYWORD_FALSE);
            }
            else if ((saveMode == ConfigurationSaveMode.Full) ||
                    (saveMode == ConfigurationSaveMode.Modified  && configSection.SectionInformation.RestartOnExternalChangesModified)) {
                AppendAttribute(sb, KEYWORD_SECTION_RESTARTONEXTERNALCHANGES, KEYWORD_TRUE);
            }

            if (!configSection.SectionInformation.RequirePermission) {
                AppendAttribute(sb, KEYWORD_SECTION_REQUIREPERMISSION, KEYWORD_FALSE);
            }
            else if ((saveMode == ConfigurationSaveMode.Full) ||
                    (saveMode == ConfigurationSaveMode.Modified  && configSection.SectionInformation.RequirePermissionModified)) {
                AppendAttribute(sb, KEYWORD_SECTION_REQUIREPERMISSION, KEYWORD_TRUE);
            }

            sb.Append("/>");

            return sb.ToString();
        }

 private bool AreDeclarationAttributesModified(FactoryRecord factoryRecord, ConfigurationSection configSection) {
     return     factoryRecord.FactoryTypeName != configSection.SectionInformation.Type
             || factoryRecord.AllowLocation != configSection.SectionInformation.AllowLocation
             || factoryRecord.RestartOnExternalChanges != configSection.SectionInformation.RestartOnExternalChanges
             || factoryRecord.RequirePermission != configSection.SectionInformation.RequirePermission
             || factoryRecord.AllowDefinition != configSection.SectionInformation.AllowDefinition
             || factoryRecord.AllowExeDefinition != configSection.SectionInformation.AllowExeDefinition
             || factoryRecord.OverrideModeDefault.OverrideMode != configSection.SectionInformation.OverrideModeDefaultSetting.OverrideMode   // Compare the value only
             || configSection.SectionInformation.IsModifiedFlags();
 }

        //
        // Create the factory object that is used to create new instances of a ConfigurationSection.
        // Our factory is a ConstructorInfo that creates the section.
        //
        override protected object CreateSectionFactory(FactoryRecord factoryRecord) {

            // Get the type of the factory
            Type type = TypeUtil.GetTypeWithReflectionPermission(Host, factoryRecord.FactoryTypeName, true);

            //
            // If the type is not a ConfigurationSection, use the DefaultSection if the type
            // implements IConfigurationSectionHandler.
            //
            if (!typeof(ConfigurationSection).IsAssignableFrom(type)) {
                TypeUtil.VerifyAssignableType(typeof(IConfigurationSectionHandler), type, true);
                type = typeof(DefaultSection);
            }

            ConstructorInfo ctor = TypeUtil.GetConstructorWithReflectionPermission(type, typeof(ConfigurationSection), true);

            return ctor;
        }

 private void InitWithRestrictedPermissions(RuntimeConfigurationRecord configRecord, FactoryRecord factoryRecord)
 {
     Init(configRecord, factoryRecord);
 }

 private object CreateSectionWithRestrictedPermissions(
         RuntimeConfigurationRecord configRecord, FactoryRecord factoryRecord, SectionRecord sectionRecord, 
         object parentConfig, ConfigXmlReader reader)
 {
     return CreateSectionImpl(configRecord, factoryRecord, sectionRecord, parentConfig, reader);
 }

 internal RuntimeConfigurationFactory(RuntimeConfigurationRecord configRecord, FactoryRecord factoryRecord) {
     // If the factory record was defined in a trusted config record, ignore user code on stack
     if (factoryRecord.IsFromTrustedConfigRecord) {
         InitWithFullTrust(configRecord, factoryRecord);
     }
     else {
         // Run configuration section handlers as if user code was on the stack
         InitWithRestrictedPermissions(configRecord, factoryRecord);
     }
 }

            private void Init(RuntimeConfigurationRecord configRecord, FactoryRecord factoryRecord) {
                // Get the type of the factory
                Type type = TypeUtil.GetTypeWithReflectionPermission(configRecord.Host, factoryRecord.FactoryTypeName, true);

                // If the type is a ConfigurationSection, that's the type.
                if (typeof(ConfigurationSection).IsAssignableFrom(type)) {
                    _sectionCtor = TypeUtil.GetConstructorWithReflectionPermission(type, typeof(ConfigurationSection), true);
                }
                else {
                    // Note: in v1, IConfigurationSectionHandler is in effect a factory that has a Create method
                    // that creates the real section object.

                    // throws if type does not implement IConfigurationSectionHandler
                    TypeUtil.VerifyAssignableType(typeof(IConfigurationSectionHandler), type, true);

                    // Create an instance of the handler
                    _sectionHandler = (IConfigurationSectionHandler) TypeUtil.CreateInstanceWithReflectionPermission(type);
                }
            }

        //
        // Create the ConfigurationSection.
        //
        override protected object CreateSection(bool inputIsTrusted, FactoryRecord factoryRecord, SectionRecord sectionRecord, object parentConfig, ConfigXmlReader reader) {
            // Create an instance of the ConfigurationSection
            ConstructorInfo ctor = (ConstructorInfo) factoryRecord.Factory;
            ConfigurationSection configSection = (ConfigurationSection) TypeUtil.InvokeCtorWithReflectionPermission(ctor);

            // Attach the ConfigurationSection to this record
            configSection.SectionInformation.AttachToConfigurationRecord(this, factoryRecord, sectionRecord);
            configSection.CallInit();

            // Initialize the ConfigurationSection with XML or just its parent.
            ConfigurationSection parentConfigSection = (ConfigurationSection) parentConfig;
            configSection.Reset(parentConfigSection);
            if (reader != null) {
                configSection.DeserializeSection(reader);
            }

            // Clear the modified bit.
            configSection.ResetModified();

            return configSection;
        }