SectionInformation.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ Dotnetfx_Vista_SP2 / Dotnetfx_Vista_SP2 / 8.0.50727.4016 / DEVDIV / depot / DevDiv / releases / whidbey / NetFxQFE / ndp / fx / src / Configuration / System / Configuration / SectionInformation.cs / 1 / SectionInformation.cs

                            //------------------------------------------------------------------------------ 
// 
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// 
//----------------------------------------------------------------------------- 

namespace System.Configuration { 
    using System; 
    using System.Collections.Specialized;
    using System.Configuration.Internal; 
    using System.IO;
    using System.Reflection;
    using System.Security;
    using System.Text; 
    using System.Xml;
    using System.Globalization; 
 
    public sealed class SectionInformation {
        // Flags 
        private const int Flag_Attached                     = 0x00000001;
        private const int Flag_Declared                     = 0x00000002;
        private const int Flag_DeclarationRequired          = 0x00000004;
        private const int Flag_AllowLocation                = 0x00000008; 
        private const int Flag_RestartOnExternalChanges     = 0x00000010;
        private const int Flag_RequirePermission            = 0x00000020; 
        private const int Flag_LocationLocked               = 0x00000040; 
        private const int Flag_ChildrenLocked               = 0x00000080;
        private const int Flag_InheritInChildApps           = 0x00000100; 
        private const int Flag_IsParentSection              = 0x00000200;
        private const int Flag_Removed                      = 0x00000400;
        private const int Flag_ProtectionProviderDetermined = 0x00000800;
        private const int Flag_ForceSave                    = 0x00001000; 
        private const int Flag_IsUndeclared                 = 0x00002000;
        private const int Flag_ChildrenLockWithoutFileInput         = 0x00004000; 
 
        private const int Flag_AllowExeDefinitionModified   = 0x00010000;
        private const int Flag_AllowDefinitionModified      = 0x00020000; 
        private const int Flag_ConfigSourceModified         = 0x00040000;
        private const int Flag_ProtectionProviderModified   = 0x00080000;
        private const int Flag_OverrideModeDefaultModified  = 0x00100000;
        private const int Flag_OverrideModeModified         = 0x00200000;   // Used only for modified tracking 

        private ConfigurationSection            _configurationSection; 
        private SafeBitVector32                 _flags; 
        private SimpleBitVector32               _modifiedFlags;
        private ConfigurationAllowDefinition    _allowDefinition; 
        private ConfigurationAllowExeDefinition _allowExeDefinition;
        private MgmtConfigurationRecord         _configRecord;
        private string                          _configKey;
        private string                          _group; 
        private string                          _name;
        private string                          _typeName; 
        private string                          _rawXml; 
        private string                          _configSource;
        private string                          _configSourceStreamName; 
        private ProtectedConfigurationProvider  _protectionProvider;
        private string                          _protectionProviderName;
        private OverrideModeSetting             _overrideModeDefault;       // The default mode for the section in _configurationSection
        private OverrideModeSetting             _overrideMode;              // The override mode at the current config path 

        // 
        // Constructor 
        //
        internal SectionInformation(ConfigurationSection associatedConfigurationSection) { 
            _configKey = String.Empty;
            _group = String.Empty;
            _name = String.Empty;
 
            _configurationSection   = associatedConfigurationSection;
            _allowDefinition        = ConfigurationAllowDefinition.Everywhere; 
            _allowExeDefinition     = ConfigurationAllowExeDefinition.MachineToApplication; 
            _overrideModeDefault    = OverrideModeSetting.SectionDefault;
            _overrideMode           = OverrideModeSetting.LocationDefault; 

            _flags[ Flag_AllowLocation            ] = true;
            _flags[ Flag_RestartOnExternalChanges ] = true;
            _flags[ Flag_RequirePermission        ] = true; 
            _flags[ Flag_InheritInChildApps       ] = true;
            _flags[ Flag_ForceSave                ] = false; 
 
            _modifiedFlags = new SimpleBitVector32();
        } 

        internal void ResetModifiedFlags() {
            _modifiedFlags = new SimpleBitVector32();
        } 

        internal bool IsModifiedFlags() { 
            return (_modifiedFlags.Data != 0); 
        }
        // for instantiation of a ConfigurationSection from GetConfig 
        internal void AttachToConfigurationRecord(MgmtConfigurationRecord configRecord, FactoryRecord factoryRecord, SectionRecord sectionRecord) {
            SetRuntimeConfigurationInformation(configRecord, factoryRecord, sectionRecord);
            _configRecord = configRecord;
        } 

        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; 
            _overrideModeDefault                    = factoryRecord.OverrideModeDefault;

            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; 
            _flags[ Flag_ChildrenLocked ]               = sectionRecord.LockChildren; 
            _flags[ Flag_ChildrenLockWithoutFileInput]  = sectionRecord.LockChildrenWithoutFileInput;
 
            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;
                _overrideMode                       = sectionXmlInfo.OverrideModeSetting;
                _flags[ Flag_InheritInChildApps ]   = !sectionXmlInfo.SkipInChildApps;
                _protectionProviderName             = sectionXmlInfo.ProtectionProviderName; 
            }
            else { 
                _flags[ Flag_ProtectionProviderDetermined ] = false; 
                _protectionProvider = null;
            } 

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

        internal void DetachFromConfigurationRecord() { 
            RevertToParent(); 
            _flags[ Flag_Attached ] = false;
            _configRecord = null; 
        }

        private bool IsRuntime {
            get { 
                return ( _flags[ Flag_Attached ] ) &&
                       ( _configRecord == null   ); 
            } 
        }
 
        internal bool Attached {
            get {return _flags[ Flag_Attached ];}
        }
 
        private void VerifyDesigntime() {
            if (IsRuntime) { 
                throw new InvalidOperationException(SR.GetString(SR.Config_operation_not_runtime)); 
            }
        } 

        private void VerifyIsAttachedToConfigRecord() {
            if (_configRecord == null) {
                throw new InvalidOperationException(SR.GetString(SR.Config_cannot_edit_configurationsection_when_not_attached)); 
            }
        } 
 
        // VerifyIsEditable
        // 
        // Verify the section is Editable.
        // It may not be editable for the following reasons:
        //   - We are in Runtime mode, not Design time
        //   - The section is not attached to a _configRecord. 
        //   - We are locked (ie. allowOveride = false )
        //   - We are a parent section (ie. Retrieved from GetParentSection) 
        // 
        internal void VerifyIsEditable() {
            VerifyDesigntime(); 

            if (IsLocked) {
                throw new InvalidOperationException(SR.GetString(SR.Config_cannot_edit_configurationsection_when_locked));
            } 

            if (_flags[Flag_IsParentSection]) { 
                throw new InvalidOperationException(SR.GetString(SR.Config_cannot_edit_configurationsection_parentsection)); 
            }
 
            if ( !_flags[ Flag_AllowLocation ] &&
                 ( _configRecord != null ) &&
                 ( _configRecord.IsLocationConfig ) ) {
                throw new InvalidOperationException(SR.GetString(SR.Config_cannot_edit_configurationsection_when_location_locked)); 
            }
        } 
 
        // VerifyNotParentSection
        // 
        // Verify that this is not a parent section
        //
        private void VerifyNotParentSection() {
            if ( _flags[Flag_IsParentSection] ) { 
                throw new InvalidOperationException(SR.GetString(SR.Config_configsection_parentnotvalid));
           } 
        } 

        // VerifySupportsLocation 
        //
        // Verify that we support the location tag.  This is true either
        // in machine.config, or in any place for the web config system
        // 
        private void VerifySupportsLocation() {
            if ( ( _configRecord != null ) && 
                 !_configRecord.RecordSupportsLocation ) { 
                throw new InvalidOperationException(SR.GetString(SR.Config_cannot_edit_locationattriubtes));
            } 
        }

        internal void VerifyIsEditableFactory() {
            if (_configRecord != null && _configRecord.IsLocationConfig) { 
                throw new InvalidOperationException(SR.GetString(SR.Config_cannot_edit_configurationsection_in_location_config));
            } 
 
            // Can't edit factory if the section is built-in
            if (BaseConfigurationRecord.IsImplicitSection(ConfigKey)) { 
                throw new InvalidOperationException(SR.GetString(SR.Config_cannot_edit_configurationsection_when_it_is_implicit));
            }

            // Can't edit undeclared section 
            if (_flags[Flag_IsUndeclared]) {
                throw new InvalidOperationException(SR.GetString(SR.Config_cannot_edit_configurationsection_when_it_is_undeclared)); 
            } 
        }
 
        internal string ConfigKey {
            get {return _configKey;}
        }
 
        internal bool Removed {
            get { 
                return _flags[ Flag_Removed ]; 
            }
            set { 
                _flags[ Flag_Removed ] = value;
            }
        }
 
        private FactoryRecord FindParentFactoryRecord(bool permitErrors) {
            FactoryRecord factoryRecord = null; 
 
            if (_configRecord != null && !_configRecord.Parent.IsRootConfig) {
                factoryRecord = _configRecord.Parent.FindFactoryRecord(_configKey, permitErrors); 
            }

            return factoryRecord;
        } 

        // 
        // public properties and methods 
        //
        public string SectionName { 
            get {return _configKey;}
        }

        public string Name { 
            get {return _name;}
        } 
 
        public ConfigurationAllowDefinition AllowDefinition {
            get {return _allowDefinition;} 
            set {
                VerifyIsEditable();
                VerifyIsEditableFactory();
 
                // allow AllowDefinition to be different from current type,
                // so long as it doesn't conflict with a type already defined 
                FactoryRecord factoryRecord = FindParentFactoryRecord(false); 
                if (factoryRecord != null && factoryRecord.AllowDefinition != value) {
                    throw new ConfigurationErrorsException(SR.GetString(SR.Config_tag_name_already_defined, _configKey)); 
                }

                _allowDefinition = value;
                _modifiedFlags[ Flag_AllowDefinitionModified       ] = true; 
            }
        } 
 
        internal bool AllowDefinitionModified {
            get { 
                return _modifiedFlags[ Flag_AllowDefinitionModified ];
            }
        }
 
        public ConfigurationAllowExeDefinition AllowExeDefinition {
            get {return _allowExeDefinition;} 
            set { 
                VerifyIsEditable();
                VerifyIsEditableFactory(); 

                // allow AllowDefinition to be different from current type,
                // so long as it doesn't conflict with a type already defined
                FactoryRecord factoryRecord = FindParentFactoryRecord(false); 
                if (factoryRecord != null && factoryRecord.AllowExeDefinition != value) {
                    throw new ConfigurationErrorsException(SR.GetString(SR.Config_tag_name_already_defined, _configKey)); 
                } 

                _allowExeDefinition = value; 
                _modifiedFlags[ Flag_AllowExeDefinitionModified       ] = true;
            }
        }
 
        internal bool AllowExeDefinitionModified {
            get { 
                return _modifiedFlags[ Flag_AllowExeDefinitionModified ]; 
            }
        } 

        public OverrideMode OverrideModeDefault {
            get {return _overrideModeDefault.OverrideMode;}
            set { 
                VerifyIsEditable();
                VerifyIsEditableFactory(); 
 
                // allow OverrideModeDefault to be different from current value,
                // so long as it doesn't conflict with a type already defined 
                FactoryRecord factoryRecord = FindParentFactoryRecord(false);
                if (factoryRecord != null && factoryRecord.OverrideModeDefault.OverrideMode != value) {
                    throw new ConfigurationErrorsException(SR.GetString(SR.Config_tag_name_already_defined, _configKey));
                } 

                // Threat "Inherit" as "Allow" as "Inherit" does not make sense as a default 
                if (value == OverrideMode.Inherit) { 
                    value = OverrideMode.Allow;
                } 

                _overrideModeDefault.OverrideMode = value;
                _modifiedFlags[ Flag_OverrideModeDefaultModified       ] = true;
            } 
        }
 
        internal OverrideModeSetting OverrideModeDefaultSetting { 
            get { return _overrideModeDefault; }
        } 

        internal bool OverrideModeDefaultModified {
            get {
                return _modifiedFlags[ Flag_OverrideModeDefaultModified ]; 
            }
        } 
 

        public bool AllowLocation { 
            get {
                return _flags[ Flag_AllowLocation ];
            }
            set { 
                VerifyIsEditable();
                VerifyIsEditableFactory(); 
 
                // allow AllowLocation to be different from current type,
                // so long as it doesn't conflict with a type already defined 
                FactoryRecord factoryRecord = FindParentFactoryRecord(false);
                if (factoryRecord != null && factoryRecord.AllowLocation != value) {
                    throw new ConfigurationErrorsException(SR.GetString(SR.Config_tag_name_already_defined, _configKey));
                } 

                _flags[ Flag_AllowLocation ] = value; 
                _modifiedFlags[ Flag_AllowLocation ] = true; 
            }
        } 

        internal bool AllowLocationModified {
            get {
                return _modifiedFlags[ Flag_AllowLocation ]; 
            }
        } 
 
        public bool AllowOverride {
            get { 
                return _overrideMode.AllowOverride;
            }
            set {
                VerifyIsEditable(); 
                VerifySupportsLocation();
                _overrideMode.AllowOverride = value; 
                _modifiedFlags[ Flag_OverrideModeModified] = true; 
            }
        } 

        public OverrideMode OverrideMode {
            get {
                return _overrideMode.OverrideMode; 
            }
            set { 
                VerifyIsEditable(); 
                VerifySupportsLocation();
                _overrideMode.OverrideMode = value; 
                _modifiedFlags[ Flag_OverrideModeModified] = true;

                // Modify the state of OverrideModeEffective according to the changes to the current mode
                switch(value) { 
                    case OverrideMode.Inherit:
                        // Wehen the state is changing to inherit - apply the value from parent which does not 
                        // include the file input lock mode 
                        _flags[Flag_ChildrenLocked] = _flags[Flag_ChildrenLockWithoutFileInput];
                        break; 

                    case OverrideMode.Allow:
                        _flags[Flag_ChildrenLocked] = false;
                        break; 

                    case OverrideMode.Deny: 
                        _flags[Flag_ChildrenLocked] = true; 
                        break;
 
                    default:
                        Debug.Assert(false,"Unexpected value for OverrideMode");
                        break;
                } 
            }
        } 
 
        public OverrideMode OverrideModeEffective {
            get { 
                return (_flags[Flag_ChildrenLocked] ? OverrideMode.Deny : OverrideMode.Allow);
            }
        }
 
        internal OverrideModeSetting OverrideModeSetting {
            get { return _overrideMode; } 
        } 

 
        // LocationAttributesAreDefault
        //
        // Are the location attributes for this section set to the
        // default settings? 
        //
        internal bool LocationAttributesAreDefault { 
            get { 
                return ( _overrideMode.IsDefaultForLocationTag &&
                         ( _flags[ Flag_InheritInChildApps ] == true ) ); 
            }
        }

        public string ConfigSource { 
            get {
               if (_configSource != null) { 
                   return _configSource; 
               }
               else { 
                   return String.Empty;
               }
            }
 
            set {
                string configSource; 
 
                VerifyIsEditable();
 
                if (!String.IsNullOrEmpty(value)) {
                    configSource = BaseConfigurationRecord.NormalizeConfigSource(value, null);
                }
                else { 
                    configSource = null;
                } 
 
                // return early if there is no change
                if (configSource == _configSource) 
                    return;

                if (_configRecord != null) {
                    _configRecord.ChangeConfigSource(this, _configSource, _configSourceStreamName, configSource); 
                }
 
                _configSource = configSource; 
                _modifiedFlags[Flag_ConfigSourceModified] = true;
            } 
        }

        internal bool ConfigSourceModified {
            get { 
                return _modifiedFlags[Flag_ConfigSourceModified];
            } 
        } 

        internal string ConfigSourceStreamName { 
            get {
                return _configSourceStreamName;
            }
 
            set {
                _configSourceStreamName = value; 
            } 
        }
 
        public bool InheritInChildApplications {
            get {
                return _flags[ Flag_InheritInChildApps ];
            } 
            set {
                VerifyIsEditable(); 
                VerifySupportsLocation(); 
                _flags[ Flag_InheritInChildApps ] = value;
            } 
        }

        // True if the section is declared at the current level
        public bool IsDeclared { 
            get {
                VerifyNotParentSection(); 
 
                return _flags[ Flag_Declared ];
            } 
        }

        // IsDeclarationRequired
        // 
        // Is the Declaration Required.  It is required if it is not set
        // in a parent, or the parent entry does not have the type 
        // 
        public bool IsDeclarationRequired {
            get { 
                VerifyNotParentSection();

                return _flags[Flag_DeclarationRequired];
            } 
        }
 
        // Force the section declaration to be written out during Save. 
        public void ForceDeclaration() {
            ForceDeclaration( true ); 
        }

        // If force==false, it actually means don't declare it at
        // the current level. 
        public void ForceDeclaration(bool force) {
            VerifyIsEditable(); 
 
            if ( ( force == false ) &&
                 _flags[ Flag_DeclarationRequired ] ) 
            {
                // Since it is required, we can not remove it
            }
            else 
            {
                // 
                // 

 


                if (force == true && BaseConfigurationRecord.IsImplicitSection(SectionName)) {
                    throw new ConfigurationErrorsException(SR.GetString(SR.Cannot_declare_or_remove_implicit_section)); 
                }
 
                if (force == true && _flags[ Flag_IsUndeclared ] ) { 
                    throw new ConfigurationErrorsException(SR.GetString(SR.Config_cannot_edit_configurationsection_when_it_is_undeclared));
                } 

                _flags[ Flag_Declared ] = force;
            }
        } 

        // IsDefinitionAllowed 
        // 
        // Is the Definition Allowed at this point.  This is all depending
        // on the Definition that is allowed, and what context we are 
        // writing the file
        //
        private bool IsDefinitionAllowed {
            get { 
                if (_configRecord == null) {
                    return true; 
                } 
                else {
                    return _configRecord.IsDefinitionAllowed(_allowDefinition, _allowExeDefinition); 
                }
            }
        }
 
        public bool IsLocked {
            get { 
                return _flags[Flag_LocationLocked] || !IsDefinitionAllowed || 
                    _configurationSection.ElementInformation.IsLocked;  // See VSWhidbey 484189
            } 
        }

        public bool IsProtected {
            get {return (ProtectionProvider != null);} 
        }
 
        public ProtectedConfigurationProvider ProtectionProvider { 
            get {
                if (!_flags[ Flag_ProtectionProviderDetermined] && _configRecord != null) { 
                    _protectionProvider = _configRecord.GetProtectionProviderFromName(_protectionProviderName, false);
                    _flags[ Flag_ProtectionProviderDetermined ] = true;
                }
 
                return _protectionProvider;
            } 
        } 

        // method to cause a section to be protected using the specified provider 
        public void ProtectSection(string protectionProvider) {
            ProtectedConfigurationProvider protectedConfigurationProvider = null;

            VerifyIsEditable(); 

            // Do not encrypt sections that will be read by a native reader. 
            // These sections are be marked with allowLocation=false. 
            // Also, the configProtectedData section cannot be encrypted!
            if (!AllowLocation || _configKey == BaseConfigurationRecord.RESERVED_SECTION_PROTECTED_CONFIGURATION) { 
                throw new InvalidOperationException(SR.GetString(SR.Config_not_allowed_to_encrypt_this_section));
            }

            if (_configRecord != null) { 
                if (String.IsNullOrEmpty(protectionProvider)) {
                    protectionProvider = _configRecord.DefaultProviderName; 
                } 

                protectedConfigurationProvider = _configRecord.GetProtectionProviderFromName(protectionProvider, true); 
            }
            else {
                throw new InvalidOperationException(SR.GetString(SR.Must_add_to_config_before_protecting_it));
            } 

            _protectionProviderName = protectionProvider; 
            _protectionProvider = protectedConfigurationProvider; 

            _flags[ Flag_ProtectionProviderDetermined ] = true; 
            _modifiedFlags[ Flag_ProtectionProviderModified ] = true;
        }

        public void UnprotectSection() { 
            VerifyIsEditable();
 
            _protectionProvider = null; 
            _protectionProviderName = null;
            _flags[ Flag_ProtectionProviderDetermined ] = true; 
            _modifiedFlags[ Flag_ProtectionProviderModified ] = true;
        }

        internal string ProtectionProviderName { 
            get { return _protectionProviderName; }
        } 
 
        public bool RestartOnExternalChanges {
            get { 
                return _flags[ Flag_RestartOnExternalChanges ];
            }
            set {
                VerifyIsEditable(); 
                VerifyIsEditableFactory();
 
                // allow RestartOnExternalChanges to be different from current type, 
                // so long as it doesn't conflict with a type already defined
                FactoryRecord factoryRecord = FindParentFactoryRecord(false); 
                if (factoryRecord != null && factoryRecord.RestartOnExternalChanges != value) {
                    throw new ConfigurationErrorsException(SR.GetString(SR.Config_tag_name_already_defined, _configKey));
                }
 
                _flags[ Flag_RestartOnExternalChanges ] = value;
                _modifiedFlags[ Flag_RestartOnExternalChanges ] = true; 
            } 
        }
 
        internal bool RestartOnExternalChangesModified {
            get {
                return _modifiedFlags[ Flag_RestartOnExternalChanges ];
            } 
        }
 
        public bool RequirePermission { 
            get {
                return _flags[ Flag_RequirePermission ]; 
            }
            set {
                VerifyIsEditable();
                VerifyIsEditableFactory(); 

                // allow RequirePermission to be different from current type, 
                // so long as it doesn't conflict with a type already defined 
                FactoryRecord factoryRecord = FindParentFactoryRecord(false);
                if (factoryRecord != null && factoryRecord.RequirePermission != value) { 
                    throw new ConfigurationErrorsException(SR.GetString(SR.Config_tag_name_already_defined, _configKey));
                }

                _flags[ Flag_RequirePermission ] = value; 
                _modifiedFlags[ Flag_RequirePermission ] = true;
            } 
        } 

        internal bool RequirePermissionModified { 
            get {
                return _modifiedFlags[ Flag_RequirePermission ];
            }
        } 

 
        public string Type { 
            get {return _typeName;}
            set { 
                if (String.IsNullOrEmpty(value)) {
                    throw ExceptionUtil.PropertyNullOrEmpty("Type");
                }
 
                VerifyIsEditable();
                VerifyIsEditableFactory(); 
 
                // allow type to be different from current type,
                // so long as it doesn't conflict with a type already defined 
                FactoryRecord factoryRecord = FindParentFactoryRecord(false);
                if (factoryRecord != null) {
                    IInternalConfigHost host = null;
                    if (_configRecord != null) { 
                        host = _configRecord.Host;
                    } 
 
                    if (!factoryRecord.IsEquivalentType(host, value)) {
                        throw new ConfigurationErrorsException(SR.GetString(SR.Config_tag_name_already_defined, _configKey)); 
                    }
                }

                _typeName = value; 
            }
        } 
 
        public ConfigurationSection GetParentSection() {
            VerifyDesigntime(); 

            if ( _flags[ Flag_IsParentSection ] ) {
                throw new InvalidOperationException(SR.GetString(SR.Config_getparentconfigurationsection_first_instance));
            } 

            // if a users create a configsection with : sectionType sec  = new sectionType(); 
            // the config record will be null.  Return null for the parent in this case. 
            ConfigurationSection ancestor = null;
            if (_configRecord != null) { 
                ancestor = _configRecord.FindAndCloneImmediateParentSection(_configurationSection);
                if (ancestor != null) {
                    ancestor.SectionInformation._flags[Flag_IsParentSection]     = true;
                    ancestor.SetReadOnly(); 
                }
            } 
 
            return ancestor;
        } 

        public string GetRawXml() {
            VerifyDesigntime();
            VerifyNotParentSection(); 

            if (RawXml != null) { 
                return RawXml; 
            }
            else if (_configRecord != null) { 
                return _configRecord.GetRawXml(_configKey);
            }
            else {
                return null; 
            }
        } 
 
        public void SetRawXml(string rawXml) {
            VerifyIsEditable(); 

            if (_configRecord != null) {
                _configRecord.SetRawXml(_configurationSection, rawXml);
            } 
            else {
                RawXml = (String.IsNullOrEmpty(rawXml)) ? null : rawXml; 
            } 
        }
 
        internal string RawXml {
            get {
                return _rawXml;
            } 

            set { 
                _rawXml = value; 
            }
        } 

        // True if the section will be serialized to the current hierarchy level, regardless of
        // ConfigurationSaveMode.
        public bool ForceSave 
        {
            get { 
                return _flags[ Flag_ForceSave ]; 
            }
            set { 
                VerifyIsEditable();

                _flags[ Flag_ForceSave ] = value;
            } 
        }
 
        public void RevertToParent() { 
            VerifyIsEditable();
            VerifyIsAttachedToConfigRecord(); 

            _configRecord.RevertToParent(_configurationSection);
        }
    } 
}

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
//------------------------------------------------------------------------------ 
// 
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// 
//----------------------------------------------------------------------------- 

namespace System.Configuration { 
    using System; 
    using System.Collections.Specialized;
    using System.Configuration.Internal; 
    using System.IO;
    using System.Reflection;
    using System.Security;
    using System.Text; 
    using System.Xml;
    using System.Globalization; 
 
    public sealed class SectionInformation {
        // Flags 
        private const int Flag_Attached                     = 0x00000001;
        private const int Flag_Declared                     = 0x00000002;
        private const int Flag_DeclarationRequired          = 0x00000004;
        private const int Flag_AllowLocation                = 0x00000008; 
        private const int Flag_RestartOnExternalChanges     = 0x00000010;
        private const int Flag_RequirePermission            = 0x00000020; 
        private const int Flag_LocationLocked               = 0x00000040; 
        private const int Flag_ChildrenLocked               = 0x00000080;
        private const int Flag_InheritInChildApps           = 0x00000100; 
        private const int Flag_IsParentSection              = 0x00000200;
        private const int Flag_Removed                      = 0x00000400;
        private const int Flag_ProtectionProviderDetermined = 0x00000800;
        private const int Flag_ForceSave                    = 0x00001000; 
        private const int Flag_IsUndeclared                 = 0x00002000;
        private const int Flag_ChildrenLockWithoutFileInput         = 0x00004000; 
 
        private const int Flag_AllowExeDefinitionModified   = 0x00010000;
        private const int Flag_AllowDefinitionModified      = 0x00020000; 
        private const int Flag_ConfigSourceModified         = 0x00040000;
        private const int Flag_ProtectionProviderModified   = 0x00080000;
        private const int Flag_OverrideModeDefaultModified  = 0x00100000;
        private const int Flag_OverrideModeModified         = 0x00200000;   // Used only for modified tracking 

        private ConfigurationSection            _configurationSection; 
        private SafeBitVector32                 _flags; 
        private SimpleBitVector32               _modifiedFlags;
        private ConfigurationAllowDefinition    _allowDefinition; 
        private ConfigurationAllowExeDefinition _allowExeDefinition;
        private MgmtConfigurationRecord         _configRecord;
        private string                          _configKey;
        private string                          _group; 
        private string                          _name;
        private string                          _typeName; 
        private string                          _rawXml; 
        private string                          _configSource;
        private string                          _configSourceStreamName; 
        private ProtectedConfigurationProvider  _protectionProvider;
        private string                          _protectionProviderName;
        private OverrideModeSetting             _overrideModeDefault;       // The default mode for the section in _configurationSection
        private OverrideModeSetting             _overrideMode;              // The override mode at the current config path 

        // 
        // Constructor 
        //
        internal SectionInformation(ConfigurationSection associatedConfigurationSection) { 
            _configKey = String.Empty;
            _group = String.Empty;
            _name = String.Empty;
 
            _configurationSection   = associatedConfigurationSection;
            _allowDefinition        = ConfigurationAllowDefinition.Everywhere; 
            _allowExeDefinition     = ConfigurationAllowExeDefinition.MachineToApplication; 
            _overrideModeDefault    = OverrideModeSetting.SectionDefault;
            _overrideMode           = OverrideModeSetting.LocationDefault; 

            _flags[ Flag_AllowLocation            ] = true;
            _flags[ Flag_RestartOnExternalChanges ] = true;
            _flags[ Flag_RequirePermission        ] = true; 
            _flags[ Flag_InheritInChildApps       ] = true;
            _flags[ Flag_ForceSave                ] = false; 
 
            _modifiedFlags = new SimpleBitVector32();
        } 

        internal void ResetModifiedFlags() {
            _modifiedFlags = new SimpleBitVector32();
        } 

        internal bool IsModifiedFlags() { 
            return (_modifiedFlags.Data != 0); 
        }
        // for instantiation of a ConfigurationSection from GetConfig 
        internal void AttachToConfigurationRecord(MgmtConfigurationRecord configRecord, FactoryRecord factoryRecord, SectionRecord sectionRecord) {
            SetRuntimeConfigurationInformation(configRecord, factoryRecord, sectionRecord);
            _configRecord = configRecord;
        } 

        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; 
            _overrideModeDefault                    = factoryRecord.OverrideModeDefault;

            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; 
            _flags[ Flag_ChildrenLocked ]               = sectionRecord.LockChildren; 
            _flags[ Flag_ChildrenLockWithoutFileInput]  = sectionRecord.LockChildrenWithoutFileInput;
 
            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;
                _overrideMode                       = sectionXmlInfo.OverrideModeSetting;
                _flags[ Flag_InheritInChildApps ]   = !sectionXmlInfo.SkipInChildApps;
                _protectionProviderName             = sectionXmlInfo.ProtectionProviderName; 
            }
            else { 
                _flags[ Flag_ProtectionProviderDetermined ] = false; 
                _protectionProvider = null;
            } 

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

        internal void DetachFromConfigurationRecord() { 
            RevertToParent(); 
            _flags[ Flag_Attached ] = false;
            _configRecord = null; 
        }

        private bool IsRuntime {
            get { 
                return ( _flags[ Flag_Attached ] ) &&
                       ( _configRecord == null   ); 
            } 
        }
 
        internal bool Attached {
            get {return _flags[ Flag_Attached ];}
        }
 
        private void VerifyDesigntime() {
            if (IsRuntime) { 
                throw new InvalidOperationException(SR.GetString(SR.Config_operation_not_runtime)); 
            }
        } 

        private void VerifyIsAttachedToConfigRecord() {
            if (_configRecord == null) {
                throw new InvalidOperationException(SR.GetString(SR.Config_cannot_edit_configurationsection_when_not_attached)); 
            }
        } 
 
        // VerifyIsEditable
        // 
        // Verify the section is Editable.
        // It may not be editable for the following reasons:
        //   - We are in Runtime mode, not Design time
        //   - The section is not attached to a _configRecord. 
        //   - We are locked (ie. allowOveride = false )
        //   - We are a parent section (ie. Retrieved from GetParentSection) 
        // 
        internal void VerifyIsEditable() {
            VerifyDesigntime(); 

            if (IsLocked) {
                throw new InvalidOperationException(SR.GetString(SR.Config_cannot_edit_configurationsection_when_locked));
            } 

            if (_flags[Flag_IsParentSection]) { 
                throw new InvalidOperationException(SR.GetString(SR.Config_cannot_edit_configurationsection_parentsection)); 
            }
 
            if ( !_flags[ Flag_AllowLocation ] &&
                 ( _configRecord != null ) &&
                 ( _configRecord.IsLocationConfig ) ) {
                throw new InvalidOperationException(SR.GetString(SR.Config_cannot_edit_configurationsection_when_location_locked)); 
            }
        } 
 
        // VerifyNotParentSection
        // 
        // Verify that this is not a parent section
        //
        private void VerifyNotParentSection() {
            if ( _flags[Flag_IsParentSection] ) { 
                throw new InvalidOperationException(SR.GetString(SR.Config_configsection_parentnotvalid));
           } 
        } 

        // VerifySupportsLocation 
        //
        // Verify that we support the location tag.  This is true either
        // in machine.config, or in any place for the web config system
        // 
        private void VerifySupportsLocation() {
            if ( ( _configRecord != null ) && 
                 !_configRecord.RecordSupportsLocation ) { 
                throw new InvalidOperationException(SR.GetString(SR.Config_cannot_edit_locationattriubtes));
            } 
        }

        internal void VerifyIsEditableFactory() {
            if (_configRecord != null && _configRecord.IsLocationConfig) { 
                throw new InvalidOperationException(SR.GetString(SR.Config_cannot_edit_configurationsection_in_location_config));
            } 
 
            // Can't edit factory if the section is built-in
            if (BaseConfigurationRecord.IsImplicitSection(ConfigKey)) { 
                throw new InvalidOperationException(SR.GetString(SR.Config_cannot_edit_configurationsection_when_it_is_implicit));
            }

            // Can't edit undeclared section 
            if (_flags[Flag_IsUndeclared]) {
                throw new InvalidOperationException(SR.GetString(SR.Config_cannot_edit_configurationsection_when_it_is_undeclared)); 
            } 
        }
 
        internal string ConfigKey {
            get {return _configKey;}
        }
 
        internal bool Removed {
            get { 
                return _flags[ Flag_Removed ]; 
            }
            set { 
                _flags[ Flag_Removed ] = value;
            }
        }
 
        private FactoryRecord FindParentFactoryRecord(bool permitErrors) {
            FactoryRecord factoryRecord = null; 
 
            if (_configRecord != null && !_configRecord.Parent.IsRootConfig) {
                factoryRecord = _configRecord.Parent.FindFactoryRecord(_configKey, permitErrors); 
            }

            return factoryRecord;
        } 

        // 
        // public properties and methods 
        //
        public string SectionName { 
            get {return _configKey;}
        }

        public string Name { 
            get {return _name;}
        } 
 
        public ConfigurationAllowDefinition AllowDefinition {
            get {return _allowDefinition;} 
            set {
                VerifyIsEditable();
                VerifyIsEditableFactory();
 
                // allow AllowDefinition to be different from current type,
                // so long as it doesn't conflict with a type already defined 
                FactoryRecord factoryRecord = FindParentFactoryRecord(false); 
                if (factoryRecord != null && factoryRecord.AllowDefinition != value) {
                    throw new ConfigurationErrorsException(SR.GetString(SR.Config_tag_name_already_defined, _configKey)); 
                }

                _allowDefinition = value;
                _modifiedFlags[ Flag_AllowDefinitionModified       ] = true; 
            }
        } 
 
        internal bool AllowDefinitionModified {
            get { 
                return _modifiedFlags[ Flag_AllowDefinitionModified ];
            }
        }
 
        public ConfigurationAllowExeDefinition AllowExeDefinition {
            get {return _allowExeDefinition;} 
            set { 
                VerifyIsEditable();
                VerifyIsEditableFactory(); 

                // allow AllowDefinition to be different from current type,
                // so long as it doesn't conflict with a type already defined
                FactoryRecord factoryRecord = FindParentFactoryRecord(false); 
                if (factoryRecord != null && factoryRecord.AllowExeDefinition != value) {
                    throw new ConfigurationErrorsException(SR.GetString(SR.Config_tag_name_already_defined, _configKey)); 
                } 

                _allowExeDefinition = value; 
                _modifiedFlags[ Flag_AllowExeDefinitionModified       ] = true;
            }
        }
 
        internal bool AllowExeDefinitionModified {
            get { 
                return _modifiedFlags[ Flag_AllowExeDefinitionModified ]; 
            }
        } 

        public OverrideMode OverrideModeDefault {
            get {return _overrideModeDefault.OverrideMode;}
            set { 
                VerifyIsEditable();
                VerifyIsEditableFactory(); 
 
                // allow OverrideModeDefault to be different from current value,
                // so long as it doesn't conflict with a type already defined 
                FactoryRecord factoryRecord = FindParentFactoryRecord(false);
                if (factoryRecord != null && factoryRecord.OverrideModeDefault.OverrideMode != value) {
                    throw new ConfigurationErrorsException(SR.GetString(SR.Config_tag_name_already_defined, _configKey));
                } 

                // Threat "Inherit" as "Allow" as "Inherit" does not make sense as a default 
                if (value == OverrideMode.Inherit) { 
                    value = OverrideMode.Allow;
                } 

                _overrideModeDefault.OverrideMode = value;
                _modifiedFlags[ Flag_OverrideModeDefaultModified       ] = true;
            } 
        }
 
        internal OverrideModeSetting OverrideModeDefaultSetting { 
            get { return _overrideModeDefault; }
        } 

        internal bool OverrideModeDefaultModified {
            get {
                return _modifiedFlags[ Flag_OverrideModeDefaultModified ]; 
            }
        } 
 

        public bool AllowLocation { 
            get {
                return _flags[ Flag_AllowLocation ];
            }
            set { 
                VerifyIsEditable();
                VerifyIsEditableFactory(); 
 
                // allow AllowLocation to be different from current type,
                // so long as it doesn't conflict with a type already defined 
                FactoryRecord factoryRecord = FindParentFactoryRecord(false);
                if (factoryRecord != null && factoryRecord.AllowLocation != value) {
                    throw new ConfigurationErrorsException(SR.GetString(SR.Config_tag_name_already_defined, _configKey));
                } 

                _flags[ Flag_AllowLocation ] = value; 
                _modifiedFlags[ Flag_AllowLocation ] = true; 
            }
        } 

        internal bool AllowLocationModified {
            get {
                return _modifiedFlags[ Flag_AllowLocation ]; 
            }
        } 
 
        public bool AllowOverride {
            get { 
                return _overrideMode.AllowOverride;
            }
            set {
                VerifyIsEditable(); 
                VerifySupportsLocation();
                _overrideMode.AllowOverride = value; 
                _modifiedFlags[ Flag_OverrideModeModified] = true; 
            }
        } 

        public OverrideMode OverrideMode {
            get {
                return _overrideMode.OverrideMode; 
            }
            set { 
                VerifyIsEditable(); 
                VerifySupportsLocation();
                _overrideMode.OverrideMode = value; 
                _modifiedFlags[ Flag_OverrideModeModified] = true;

                // Modify the state of OverrideModeEffective according to the changes to the current mode
                switch(value) { 
                    case OverrideMode.Inherit:
                        // Wehen the state is changing to inherit - apply the value from parent which does not 
                        // include the file input lock mode 
                        _flags[Flag_ChildrenLocked] = _flags[Flag_ChildrenLockWithoutFileInput];
                        break; 

                    case OverrideMode.Allow:
                        _flags[Flag_ChildrenLocked] = false;
                        break; 

                    case OverrideMode.Deny: 
                        _flags[Flag_ChildrenLocked] = true; 
                        break;
 
                    default:
                        Debug.Assert(false,"Unexpected value for OverrideMode");
                        break;
                } 
            }
        } 
 
        public OverrideMode OverrideModeEffective {
            get { 
                return (_flags[Flag_ChildrenLocked] ? OverrideMode.Deny : OverrideMode.Allow);
            }
        }
 
        internal OverrideModeSetting OverrideModeSetting {
            get { return _overrideMode; } 
        } 

 
        // LocationAttributesAreDefault
        //
        // Are the location attributes for this section set to the
        // default settings? 
        //
        internal bool LocationAttributesAreDefault { 
            get { 
                return ( _overrideMode.IsDefaultForLocationTag &&
                         ( _flags[ Flag_InheritInChildApps ] == true ) ); 
            }
        }

        public string ConfigSource { 
            get {
               if (_configSource != null) { 
                   return _configSource; 
               }
               else { 
                   return String.Empty;
               }
            }
 
            set {
                string configSource; 
 
                VerifyIsEditable();
 
                if (!String.IsNullOrEmpty(value)) {
                    configSource = BaseConfigurationRecord.NormalizeConfigSource(value, null);
                }
                else { 
                    configSource = null;
                } 
 
                // return early if there is no change
                if (configSource == _configSource) 
                    return;

                if (_configRecord != null) {
                    _configRecord.ChangeConfigSource(this, _configSource, _configSourceStreamName, configSource); 
                }
 
                _configSource = configSource; 
                _modifiedFlags[Flag_ConfigSourceModified] = true;
            } 
        }

        internal bool ConfigSourceModified {
            get { 
                return _modifiedFlags[Flag_ConfigSourceModified];
            } 
        } 

        internal string ConfigSourceStreamName { 
            get {
                return _configSourceStreamName;
            }
 
            set {
                _configSourceStreamName = value; 
            } 
        }
 
        public bool InheritInChildApplications {
            get {
                return _flags[ Flag_InheritInChildApps ];
            } 
            set {
                VerifyIsEditable(); 
                VerifySupportsLocation(); 
                _flags[ Flag_InheritInChildApps ] = value;
            } 
        }

        // True if the section is declared at the current level
        public bool IsDeclared { 
            get {
                VerifyNotParentSection(); 
 
                return _flags[ Flag_Declared ];
            } 
        }

        // IsDeclarationRequired
        // 
        // Is the Declaration Required.  It is required if it is not set
        // in a parent, or the parent entry does not have the type 
        // 
        public bool IsDeclarationRequired {
            get { 
                VerifyNotParentSection();

                return _flags[Flag_DeclarationRequired];
            } 
        }
 
        // Force the section declaration to be written out during Save. 
        public void ForceDeclaration() {
            ForceDeclaration( true ); 
        }

        // If force==false, it actually means don't declare it at
        // the current level. 
        public void ForceDeclaration(bool force) {
            VerifyIsEditable(); 
 
            if ( ( force == false ) &&
                 _flags[ Flag_DeclarationRequired ] ) 
            {
                // Since it is required, we can not remove it
            }
            else 
            {
                // 
                // 

 


                if (force == true && BaseConfigurationRecord.IsImplicitSection(SectionName)) {
                    throw new ConfigurationErrorsException(SR.GetString(SR.Cannot_declare_or_remove_implicit_section)); 
                }
 
                if (force == true && _flags[ Flag_IsUndeclared ] ) { 
                    throw new ConfigurationErrorsException(SR.GetString(SR.Config_cannot_edit_configurationsection_when_it_is_undeclared));
                } 

                _flags[ Flag_Declared ] = force;
            }
        } 

        // IsDefinitionAllowed 
        // 
        // Is the Definition Allowed at this point.  This is all depending
        // on the Definition that is allowed, and what context we are 
        // writing the file
        //
        private bool IsDefinitionAllowed {
            get { 
                if (_configRecord == null) {
                    return true; 
                } 
                else {
                    return _configRecord.IsDefinitionAllowed(_allowDefinition, _allowExeDefinition); 
                }
            }
        }
 
        public bool IsLocked {
            get { 
                return _flags[Flag_LocationLocked] || !IsDefinitionAllowed || 
                    _configurationSection.ElementInformation.IsLocked;  // See VSWhidbey 484189
            } 
        }

        public bool IsProtected {
            get {return (ProtectionProvider != null);} 
        }
 
        public ProtectedConfigurationProvider ProtectionProvider { 
            get {
                if (!_flags[ Flag_ProtectionProviderDetermined] && _configRecord != null) { 
                    _protectionProvider = _configRecord.GetProtectionProviderFromName(_protectionProviderName, false);
                    _flags[ Flag_ProtectionProviderDetermined ] = true;
                }
 
                return _protectionProvider;
            } 
        } 

        // method to cause a section to be protected using the specified provider 
        public void ProtectSection(string protectionProvider) {
            ProtectedConfigurationProvider protectedConfigurationProvider = null;

            VerifyIsEditable(); 

            // Do not encrypt sections that will be read by a native reader. 
            // These sections are be marked with allowLocation=false. 
            // Also, the configProtectedData section cannot be encrypted!
            if (!AllowLocation || _configKey == BaseConfigurationRecord.RESERVED_SECTION_PROTECTED_CONFIGURATION) { 
                throw new InvalidOperationException(SR.GetString(SR.Config_not_allowed_to_encrypt_this_section));
            }

            if (_configRecord != null) { 
                if (String.IsNullOrEmpty(protectionProvider)) {
                    protectionProvider = _configRecord.DefaultProviderName; 
                } 

                protectedConfigurationProvider = _configRecord.GetProtectionProviderFromName(protectionProvider, true); 
            }
            else {
                throw new InvalidOperationException(SR.GetString(SR.Must_add_to_config_before_protecting_it));
            } 

            _protectionProviderName = protectionProvider; 
            _protectionProvider = protectedConfigurationProvider; 

            _flags[ Flag_ProtectionProviderDetermined ] = true; 
            _modifiedFlags[ Flag_ProtectionProviderModified ] = true;
        }

        public void UnprotectSection() { 
            VerifyIsEditable();
 
            _protectionProvider = null; 
            _protectionProviderName = null;
            _flags[ Flag_ProtectionProviderDetermined ] = true; 
            _modifiedFlags[ Flag_ProtectionProviderModified ] = true;
        }

        internal string ProtectionProviderName { 
            get { return _protectionProviderName; }
        } 
 
        public bool RestartOnExternalChanges {
            get { 
                return _flags[ Flag_RestartOnExternalChanges ];
            }
            set {
                VerifyIsEditable(); 
                VerifyIsEditableFactory();
 
                // allow RestartOnExternalChanges to be different from current type, 
                // so long as it doesn't conflict with a type already defined
                FactoryRecord factoryRecord = FindParentFactoryRecord(false); 
                if (factoryRecord != null && factoryRecord.RestartOnExternalChanges != value) {
                    throw new ConfigurationErrorsException(SR.GetString(SR.Config_tag_name_already_defined, _configKey));
                }
 
                _flags[ Flag_RestartOnExternalChanges ] = value;
                _modifiedFlags[ Flag_RestartOnExternalChanges ] = true; 
            } 
        }
 
        internal bool RestartOnExternalChangesModified {
            get {
                return _modifiedFlags[ Flag_RestartOnExternalChanges ];
            } 
        }
 
        public bool RequirePermission { 
            get {
                return _flags[ Flag_RequirePermission ]; 
            }
            set {
                VerifyIsEditable();
                VerifyIsEditableFactory(); 

                // allow RequirePermission to be different from current type, 
                // so long as it doesn't conflict with a type already defined 
                FactoryRecord factoryRecord = FindParentFactoryRecord(false);
                if (factoryRecord != null && factoryRecord.RequirePermission != value) { 
                    throw new ConfigurationErrorsException(SR.GetString(SR.Config_tag_name_already_defined, _configKey));
                }

                _flags[ Flag_RequirePermission ] = value; 
                _modifiedFlags[ Flag_RequirePermission ] = true;
            } 
        } 

        internal bool RequirePermissionModified { 
            get {
                return _modifiedFlags[ Flag_RequirePermission ];
            }
        } 

 
        public string Type { 
            get {return _typeName;}
            set { 
                if (String.IsNullOrEmpty(value)) {
                    throw ExceptionUtil.PropertyNullOrEmpty("Type");
                }
 
                VerifyIsEditable();
                VerifyIsEditableFactory(); 
 
                // allow type to be different from current type,
                // so long as it doesn't conflict with a type already defined 
                FactoryRecord factoryRecord = FindParentFactoryRecord(false);
                if (factoryRecord != null) {
                    IInternalConfigHost host = null;
                    if (_configRecord != null) { 
                        host = _configRecord.Host;
                    } 
 
                    if (!factoryRecord.IsEquivalentType(host, value)) {
                        throw new ConfigurationErrorsException(SR.GetString(SR.Config_tag_name_already_defined, _configKey)); 
                    }
                }

                _typeName = value; 
            }
        } 
 
        public ConfigurationSection GetParentSection() {
            VerifyDesigntime(); 

            if ( _flags[ Flag_IsParentSection ] ) {
                throw new InvalidOperationException(SR.GetString(SR.Config_getparentconfigurationsection_first_instance));
            } 

            // if a users create a configsection with : sectionType sec  = new sectionType(); 
            // the config record will be null.  Return null for the parent in this case. 
            ConfigurationSection ancestor = null;
            if (_configRecord != null) { 
                ancestor = _configRecord.FindAndCloneImmediateParentSection(_configurationSection);
                if (ancestor != null) {
                    ancestor.SectionInformation._flags[Flag_IsParentSection]     = true;
                    ancestor.SetReadOnly(); 
                }
            } 
 
            return ancestor;
        } 

        public string GetRawXml() {
            VerifyDesigntime();
            VerifyNotParentSection(); 

            if (RawXml != null) { 
                return RawXml; 
            }
            else if (_configRecord != null) { 
                return _configRecord.GetRawXml(_configKey);
            }
            else {
                return null; 
            }
        } 
 
        public void SetRawXml(string rawXml) {
            VerifyIsEditable(); 

            if (_configRecord != null) {
                _configRecord.SetRawXml(_configurationSection, rawXml);
            } 
            else {
                RawXml = (String.IsNullOrEmpty(rawXml)) ? null : rawXml; 
            } 
        }
 
        internal string RawXml {
            get {
                return _rawXml;
            } 

            set { 
                _rawXml = value; 
            }
        } 

        // True if the section will be serialized to the current hierarchy level, regardless of
        // ConfigurationSaveMode.
        public bool ForceSave 
        {
            get { 
                return _flags[ Flag_ForceSave ]; 
            }
            set { 
                VerifyIsEditable();

                _flags[ Flag_ForceSave ] = value;
            } 
        }
 
        public void RevertToParent() { 
            VerifyIsEditable();
            VerifyIsAttachedToConfigRecord(); 

            _configRecord.RevertToParent(_configurationSection);
        }
    } 
}

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
                        

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK