SectionRecord.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ Dotnetfx_Win7_3.5.1 / Dotnetfx_Win7_3.5.1 / 3.5.1 / DEVDIV / depot / DevDiv / releases / whidbey / NetFXspW7 / ndp / fx / src / Configuration / System / Configuration / SectionRecord.cs / 1 / SectionRecord.cs

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

namespace System.Configuration { 
    using System.Configuration.Internal; 
    using System.Collections;
    using System.Collections.Specialized; 
    using System.Collections.Generic;
    using System.Configuration;
    using System.Text;
    using System.Threading; 
    using System.Reflection;
    using System.Xml; 
 
    [System.Diagnostics.DebuggerDisplay("SectionRecord {ConfigKey}")]
    internal class SectionRecord { 
        //
        // Flags constants
        //
 
        //
        // Runtime flags below 0x10000 
        // 

        // locked by parent input, either because a parent section is locked, 
        // a parent section locks all children, or a location input for this
        // configPath has allowOverride=false.
        private const int Flag_Locked                               = 0x00000001;
 
        // lock children of this section
        private const int Flag_LockChildren                         = 0x00000002; 
 
        // propagation of FactoryRecord.IsFactoryTrustedWithoutAptca
        private const int Flag_IsResultTrustedWithoutAptca          = 0x00000004; 

        // propagation of FactoryRecord.RequirePermission
        private const int Flag_RequirePermission                    = 0x00000008;
 
        // Look at AddLocationInput for explanation of this flag's purpose
        private const int Flag_LocationInputLockApplied             = 0x00000010; 
 
        // Look at AddIndirectLocationInput for explanation of this flag's purpose
        private const int Flag_IndirectLocationInputLockApplied     = 0x00000020; 

        // The flag gives us the inherited lock mode for this section record without the file input
        // We need this to support SectionInformation.OverrideModeEffective.
        private const int Flag_ChildrenLockWithoutFileInput         = 0x00000040; 

        // 
        // Designtime flags at or above 0x00010000 
        //
 
        // the section has been added to the update list
        private const int Flag_AddUpdate                            = 0x00010000;

        // result can be null, so we use this object to indicate whether it has been evaluated 
        static object                           s_unevaluated = new object();
 
        private SafeBitVector32                _flags; 

        // config key 
        private string                          _configKey;

        // The input from location sections
        // This list is ordered to keep oldest ancestors at the front 
        private List              _locationInputs;
 
        // The input from this file 
        private SectionInput                    _fileInput;
 
        // This special input is used only when creating a location config record.
        // The inputs are from location tags which are found in the same config file as the
        // location config configPath, but point to the parent paths of the location config
        // configPath.  See the comment for VSWhidbey 540184 in Init() in 
        // BaseConfigurationRecord.cs for more details.
        private List              _indirectLocationInputs; 
 
        // the cached result of evaluating this section
        private object                          _result; 

        // the cached result of evaluating this section after GetRuntimeObject is called
        private object                          _resultRuntimeObject;
 
        // errors not associated with a particular input
        // this it NOT the sum of all errors 
        private List    _errors; 

 
        internal SectionRecord(string configKey) {
            _configKey = configKey;
            _result = s_unevaluated;
            _resultRuntimeObject = s_unevaluated; 
        }
 
        internal string ConfigKey { 
            get {return _configKey;}
        } 

        internal bool Locked {
            get {return _flags[Flag_Locked];}
        } 

        internal bool LockChildren { 
            get {return _flags[Flag_LockChildren];} 
        }
 
        internal bool LockChildrenWithoutFileInput {
            get {

                // Start assuming we dont have a file input 
                // When we don't have file input the lock mode for children is the same for LockChildren and LockChildrenWithoutFileInput
                bool result = LockChildren; 
 
                if (HasFileInput) {
                    result =  _flags[Flag_ChildrenLockWithoutFileInput]; 
                }

                return result;
            } 
        }
 
        internal bool IsResultTrustedWithoutAptca { 
            get {return _flags[Flag_IsResultTrustedWithoutAptca];}
            set {_flags[Flag_IsResultTrustedWithoutAptca] = value;} 
        }

        internal bool RequirePermission {
            get {return _flags[Flag_RequirePermission];} 
            set {_flags[Flag_RequirePermission] = value;}
        } 
 
        internal bool AddUpdate {
            get {return _flags[Flag_AddUpdate];} 
            set {_flags[Flag_AddUpdate] = value;}
        }

        internal bool HasLocationInputs { 
            get {
                return _locationInputs != null && _locationInputs.Count > 0; 
            } 
        }
 
        internal List LocationInputs {
            get {return _locationInputs;}
        }
 
        internal SectionInput LastLocationInput {
            get { 
                if (HasLocationInputs) { 
                    return _locationInputs[_locationInputs.Count - 1];
                } 
                else {
                    return null;
                }
            } 
        }
 
        internal void 
        AddLocationInput(SectionInput sectionInput) {
            AddLocationInputImpl(sectionInput, false); 
        }

        internal bool HasFileInput {
            get { 
                return _fileInput != null;
            } 
        } 

        internal SectionInput FileInput { 
            get { return _fileInput; }
        }

        internal void ChangeLockSettings(OverrideMode forSelf, OverrideMode forChildren) { 

            if (forSelf != OverrideMode.Inherit) { 
                _flags[Flag_Locked]         = (forSelf == OverrideMode.Deny); 
                _flags[Flag_LockChildren]   = (forSelf == OverrideMode.Deny);
            } 

            if (forChildren != OverrideMode.Inherit) {
                _flags[Flag_LockChildren] = ((forSelf == OverrideMode.Deny) || (forChildren == OverrideMode.Deny));
            } 
        }
 
        // AddFileInput 
        internal void AddFileInput(SectionInput sectionInput) {
            Debug.Assert(sectionInput != null); 

            _fileInput = sectionInput;

            if (!sectionInput.HasErrors) { 

                // If the file input has an explciti value for its children locking - use it 
                // Note we dont change the current lock setting 
                if (sectionInput.SectionXmlInfo.OverrideModeSetting.OverrideMode != OverrideMode.Inherit) {
 
                    // Store the current setting before applying the lock from the file input
                    // So that if the user changes the current OverrideMode on this configKey to "Inherit"
                    // we will know what we are going to inherit ( used in SectionInformation.OverrideModeEffective )
                    // Note that we cannot use BaseConfigurationRecord.ResolveOverrideModeFromParent as it gives us only the lock 
                    // resolved up to our immediate parent which does not inlcude normal and indirect location imputs
                    _flags[Flag_ChildrenLockWithoutFileInput] = LockChildren; 
 
                    ChangeLockSettings(OverrideMode.Inherit, sectionInput.SectionXmlInfo.OverrideModeSetting.OverrideMode);
                } 
            }
        }

        internal void RemoveFileInput() { 
            if (_fileInput != null) {
                _fileInput = null; 
 
                // Reset LockChildren flag to the value provided by
                // location input or inherited sections. 
                _flags[Flag_LockChildren] = Locked;
            }
        }
 
        internal bool HasIndirectLocationInputs {
            get { 
                return _indirectLocationInputs != null && _indirectLocationInputs.Count > 0; 
            }
        } 

        internal List IndirectLocationInputs {
            get {return _indirectLocationInputs;}
        } 

        internal SectionInput LastIndirectLocationInput { 
            get { 
                if (HasIndirectLocationInputs) {
                    return _indirectLocationInputs[_indirectLocationInputs.Count - 1]; 
                }
                else {
                    return null;
                } 
            }
        } 
 
        internal void
        AddIndirectLocationInput(SectionInput sectionInput) { 
            AddLocationInputImpl(sectionInput, true);
        }

        private void 
        AddLocationInputImpl(SectionInput sectionInput, bool isIndirectLocation) {
            List  inputs = isIndirectLocation ? 
                                        _indirectLocationInputs : 
                                        _locationInputs;
 
            int                 flag = isIndirectLocation ?
                                        Flag_IndirectLocationInputLockApplied :
                                        Flag_LocationInputLockApplied;
 
            if (inputs == null) {
                inputs = new List(1); 
 
                if (isIndirectLocation) {
                    _indirectLocationInputs = inputs; 
                }
                else {
                    _locationInputs = inputs;
                } 
            }
 
            // The list of locationSections is traversed from child to parent, 
            // so insert at the beginning of the list.
            inputs.Insert(0, sectionInput); 

            // Only the overrideMode from the parent thats closest to the SectionRecord has effect
            //
            // For location input: 
            // Remember that this method will be called for location inputs comming from the immediate parent first
            // and then walking the hierarchy up to the root level 
            // 
            // For indirect location input:
            // This method will be first called for indirect input closest to the location config 
            if (!sectionInput.HasErrors) {

                if (!_flags[flag]) {
                    OverrideMode modeLocation = sectionInput.SectionXmlInfo.OverrideModeSetting.OverrideMode; 

                    if (modeLocation != OverrideMode.Inherit) { 
                        ChangeLockSettings(modeLocation, modeLocation); 
                        _flags[flag] = true;
                    } 
                }
            }
        }
 
        internal bool HasInput {
            get { 
                return HasLocationInputs || HasFileInput || HasIndirectLocationInputs; 
            }
        } 

        internal void ClearRawXml() {
            if (HasLocationInputs) {
                foreach (SectionInput locationInput in LocationInputs) { 
                    locationInput.SectionXmlInfo.RawXml = null;
                } 
            } 

            if (HasIndirectLocationInputs) { 
                foreach (SectionInput indirectLocationInput in IndirectLocationInputs) {
                    indirectLocationInput.SectionXmlInfo.RawXml = null;
                }
            } 

            if (HasFileInput) { 
                FileInput.SectionXmlInfo.RawXml = null; 
            }
        } 

        internal bool HasResult {
            get {return _result != s_unevaluated;}
        } 

        internal bool HasResultRuntimeObject { 
            get {return _resultRuntimeObject != s_unevaluated;} 
        }
 
        internal object Result {
            get {
                // Useful assert, but it fires in the debugger when using automatic property evaluation
                // Debug.Assert(_result != s_unevaluated, "_result != s_unevaluated"); 

                return _result; 
            } 

            set {_result = value;} 
        }

        internal object ResultRuntimeObject {
            get { 
                // Useful assert, but it fires in the debugger when using automatic property evaluation
                // Debug.Assert(_resultRuntimeObject != s_unevaluated, "_resultRuntimeObject != s_unevaluated"); 
 
                return _resultRuntimeObject;
            } 

            set {
                _resultRuntimeObject = value;
            } 
        }
 
        internal void ClearResult() { 
            if (_fileInput != null) {
                _fileInput.ClearResult(); 
            }

            if (_locationInputs != null) {
                foreach (SectionInput input in _locationInputs) { 
                    input.ClearResult();
                } 
            } 

            _result = s_unevaluated; 
            _resultRuntimeObject = s_unevaluated;
        }

        // 
        // Error handling.
        // 
 
        private List GetAllErrors() {
            List allErrors = null; 

            ErrorsHelper.AddErrors(ref allErrors, _errors);

            if (HasLocationInputs) { 
                foreach (SectionInput input in LocationInputs) {
                    ErrorsHelper.AddErrors(ref allErrors, input.Errors); 
                } 
            }
 
            if (HasIndirectLocationInputs) {
                foreach (SectionInput input in IndirectLocationInputs) {
                    ErrorsHelper.AddErrors(ref allErrors, input.Errors);
                } 
            }
 
            if (HasFileInput) { 
                ErrorsHelper.AddErrors(ref allErrors, FileInput.Errors);
            } 

            return allErrors;
        }
 
        internal bool HasErrors {
            get { 
                if (ErrorsHelper.GetHasErrors(_errors)) { 
                    return true;
                } 

                if (HasLocationInputs) {
                    foreach (SectionInput input in LocationInputs) {
                        if (input.HasErrors) { 
                            return true;
                        } 
                    } 
                }
 
                if (HasIndirectLocationInputs) {
                    foreach (SectionInput input in IndirectLocationInputs) {
                        if (input.HasErrors) {
                            return true; 
                        }
                    } 
                } 

                if (HasFileInput) { 
                    if (FileInput.HasErrors) {
                        return true;
                    }
                } 

                return false; 
            } 
        }
 
        internal void ThrowOnErrors() {
            if (HasErrors) {
                throw new ConfigurationErrorsException(GetAllErrors());
            } 
        }
    } 
} 


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

namespace System.Configuration { 
    using System.Configuration.Internal; 
    using System.Collections;
    using System.Collections.Specialized; 
    using System.Collections.Generic;
    using System.Configuration;
    using System.Text;
    using System.Threading; 
    using System.Reflection;
    using System.Xml; 
 
    [System.Diagnostics.DebuggerDisplay("SectionRecord {ConfigKey}")]
    internal class SectionRecord { 
        //
        // Flags constants
        //
 
        //
        // Runtime flags below 0x10000 
        // 

        // locked by parent input, either because a parent section is locked, 
        // a parent section locks all children, or a location input for this
        // configPath has allowOverride=false.
        private const int Flag_Locked                               = 0x00000001;
 
        // lock children of this section
        private const int Flag_LockChildren                         = 0x00000002; 
 
        // propagation of FactoryRecord.IsFactoryTrustedWithoutAptca
        private const int Flag_IsResultTrustedWithoutAptca          = 0x00000004; 

        // propagation of FactoryRecord.RequirePermission
        private const int Flag_RequirePermission                    = 0x00000008;
 
        // Look at AddLocationInput for explanation of this flag's purpose
        private const int Flag_LocationInputLockApplied             = 0x00000010; 
 
        // Look at AddIndirectLocationInput for explanation of this flag's purpose
        private const int Flag_IndirectLocationInputLockApplied     = 0x00000020; 

        // The flag gives us the inherited lock mode for this section record without the file input
        // We need this to support SectionInformation.OverrideModeEffective.
        private const int Flag_ChildrenLockWithoutFileInput         = 0x00000040; 

        // 
        // Designtime flags at or above 0x00010000 
        //
 
        // the section has been added to the update list
        private const int Flag_AddUpdate                            = 0x00010000;

        // result can be null, so we use this object to indicate whether it has been evaluated 
        static object                           s_unevaluated = new object();
 
        private SafeBitVector32                _flags; 

        // config key 
        private string                          _configKey;

        // The input from location sections
        // This list is ordered to keep oldest ancestors at the front 
        private List              _locationInputs;
 
        // The input from this file 
        private SectionInput                    _fileInput;
 
        // This special input is used only when creating a location config record.
        // The inputs are from location tags which are found in the same config file as the
        // location config configPath, but point to the parent paths of the location config
        // configPath.  See the comment for VSWhidbey 540184 in Init() in 
        // BaseConfigurationRecord.cs for more details.
        private List              _indirectLocationInputs; 
 
        // the cached result of evaluating this section
        private object                          _result; 

        // the cached result of evaluating this section after GetRuntimeObject is called
        private object                          _resultRuntimeObject;
 
        // errors not associated with a particular input
        // this it NOT the sum of all errors 
        private List    _errors; 

 
        internal SectionRecord(string configKey) {
            _configKey = configKey;
            _result = s_unevaluated;
            _resultRuntimeObject = s_unevaluated; 
        }
 
        internal string ConfigKey { 
            get {return _configKey;}
        } 

        internal bool Locked {
            get {return _flags[Flag_Locked];}
        } 

        internal bool LockChildren { 
            get {return _flags[Flag_LockChildren];} 
        }
 
        internal bool LockChildrenWithoutFileInput {
            get {

                // Start assuming we dont have a file input 
                // When we don't have file input the lock mode for children is the same for LockChildren and LockChildrenWithoutFileInput
                bool result = LockChildren; 
 
                if (HasFileInput) {
                    result =  _flags[Flag_ChildrenLockWithoutFileInput]; 
                }

                return result;
            } 
        }
 
        internal bool IsResultTrustedWithoutAptca { 
            get {return _flags[Flag_IsResultTrustedWithoutAptca];}
            set {_flags[Flag_IsResultTrustedWithoutAptca] = value;} 
        }

        internal bool RequirePermission {
            get {return _flags[Flag_RequirePermission];} 
            set {_flags[Flag_RequirePermission] = value;}
        } 
 
        internal bool AddUpdate {
            get {return _flags[Flag_AddUpdate];} 
            set {_flags[Flag_AddUpdate] = value;}
        }

        internal bool HasLocationInputs { 
            get {
                return _locationInputs != null && _locationInputs.Count > 0; 
            } 
        }
 
        internal List LocationInputs {
            get {return _locationInputs;}
        }
 
        internal SectionInput LastLocationInput {
            get { 
                if (HasLocationInputs) { 
                    return _locationInputs[_locationInputs.Count - 1];
                } 
                else {
                    return null;
                }
            } 
        }
 
        internal void 
        AddLocationInput(SectionInput sectionInput) {
            AddLocationInputImpl(sectionInput, false); 
        }

        internal bool HasFileInput {
            get { 
                return _fileInput != null;
            } 
        } 

        internal SectionInput FileInput { 
            get { return _fileInput; }
        }

        internal void ChangeLockSettings(OverrideMode forSelf, OverrideMode forChildren) { 

            if (forSelf != OverrideMode.Inherit) { 
                _flags[Flag_Locked]         = (forSelf == OverrideMode.Deny); 
                _flags[Flag_LockChildren]   = (forSelf == OverrideMode.Deny);
            } 

            if (forChildren != OverrideMode.Inherit) {
                _flags[Flag_LockChildren] = ((forSelf == OverrideMode.Deny) || (forChildren == OverrideMode.Deny));
            } 
        }
 
        // AddFileInput 
        internal void AddFileInput(SectionInput sectionInput) {
            Debug.Assert(sectionInput != null); 

            _fileInput = sectionInput;

            if (!sectionInput.HasErrors) { 

                // If the file input has an explciti value for its children locking - use it 
                // Note we dont change the current lock setting 
                if (sectionInput.SectionXmlInfo.OverrideModeSetting.OverrideMode != OverrideMode.Inherit) {
 
                    // Store the current setting before applying the lock from the file input
                    // So that if the user changes the current OverrideMode on this configKey to "Inherit"
                    // we will know what we are going to inherit ( used in SectionInformation.OverrideModeEffective )
                    // Note that we cannot use BaseConfigurationRecord.ResolveOverrideModeFromParent as it gives us only the lock 
                    // resolved up to our immediate parent which does not inlcude normal and indirect location imputs
                    _flags[Flag_ChildrenLockWithoutFileInput] = LockChildren; 
 
                    ChangeLockSettings(OverrideMode.Inherit, sectionInput.SectionXmlInfo.OverrideModeSetting.OverrideMode);
                } 
            }
        }

        internal void RemoveFileInput() { 
            if (_fileInput != null) {
                _fileInput = null; 
 
                // Reset LockChildren flag to the value provided by
                // location input or inherited sections. 
                _flags[Flag_LockChildren] = Locked;
            }
        }
 
        internal bool HasIndirectLocationInputs {
            get { 
                return _indirectLocationInputs != null && _indirectLocationInputs.Count > 0; 
            }
        } 

        internal List IndirectLocationInputs {
            get {return _indirectLocationInputs;}
        } 

        internal SectionInput LastIndirectLocationInput { 
            get { 
                if (HasIndirectLocationInputs) {
                    return _indirectLocationInputs[_indirectLocationInputs.Count - 1]; 
                }
                else {
                    return null;
                } 
            }
        } 
 
        internal void
        AddIndirectLocationInput(SectionInput sectionInput) { 
            AddLocationInputImpl(sectionInput, true);
        }

        private void 
        AddLocationInputImpl(SectionInput sectionInput, bool isIndirectLocation) {
            List  inputs = isIndirectLocation ? 
                                        _indirectLocationInputs : 
                                        _locationInputs;
 
            int                 flag = isIndirectLocation ?
                                        Flag_IndirectLocationInputLockApplied :
                                        Flag_LocationInputLockApplied;
 
            if (inputs == null) {
                inputs = new List(1); 
 
                if (isIndirectLocation) {
                    _indirectLocationInputs = inputs; 
                }
                else {
                    _locationInputs = inputs;
                } 
            }
 
            // The list of locationSections is traversed from child to parent, 
            // so insert at the beginning of the list.
            inputs.Insert(0, sectionInput); 

            // Only the overrideMode from the parent thats closest to the SectionRecord has effect
            //
            // For location input: 
            // Remember that this method will be called for location inputs comming from the immediate parent first
            // and then walking the hierarchy up to the root level 
            // 
            // For indirect location input:
            // This method will be first called for indirect input closest to the location config 
            if (!sectionInput.HasErrors) {

                if (!_flags[flag]) {
                    OverrideMode modeLocation = sectionInput.SectionXmlInfo.OverrideModeSetting.OverrideMode; 

                    if (modeLocation != OverrideMode.Inherit) { 
                        ChangeLockSettings(modeLocation, modeLocation); 
                        _flags[flag] = true;
                    } 
                }
            }
        }
 
        internal bool HasInput {
            get { 
                return HasLocationInputs || HasFileInput || HasIndirectLocationInputs; 
            }
        } 

        internal void ClearRawXml() {
            if (HasLocationInputs) {
                foreach (SectionInput locationInput in LocationInputs) { 
                    locationInput.SectionXmlInfo.RawXml = null;
                } 
            } 

            if (HasIndirectLocationInputs) { 
                foreach (SectionInput indirectLocationInput in IndirectLocationInputs) {
                    indirectLocationInput.SectionXmlInfo.RawXml = null;
                }
            } 

            if (HasFileInput) { 
                FileInput.SectionXmlInfo.RawXml = null; 
            }
        } 

        internal bool HasResult {
            get {return _result != s_unevaluated;}
        } 

        internal bool HasResultRuntimeObject { 
            get {return _resultRuntimeObject != s_unevaluated;} 
        }
 
        internal object Result {
            get {
                // Useful assert, but it fires in the debugger when using automatic property evaluation
                // Debug.Assert(_result != s_unevaluated, "_result != s_unevaluated"); 

                return _result; 
            } 

            set {_result = value;} 
        }

        internal object ResultRuntimeObject {
            get { 
                // Useful assert, but it fires in the debugger when using automatic property evaluation
                // Debug.Assert(_resultRuntimeObject != s_unevaluated, "_resultRuntimeObject != s_unevaluated"); 
 
                return _resultRuntimeObject;
            } 

            set {
                _resultRuntimeObject = value;
            } 
        }
 
        internal void ClearResult() { 
            if (_fileInput != null) {
                _fileInput.ClearResult(); 
            }

            if (_locationInputs != null) {
                foreach (SectionInput input in _locationInputs) { 
                    input.ClearResult();
                } 
            } 

            _result = s_unevaluated; 
            _resultRuntimeObject = s_unevaluated;
        }

        // 
        // Error handling.
        // 
 
        private List GetAllErrors() {
            List allErrors = null; 

            ErrorsHelper.AddErrors(ref allErrors, _errors);

            if (HasLocationInputs) { 
                foreach (SectionInput input in LocationInputs) {
                    ErrorsHelper.AddErrors(ref allErrors, input.Errors); 
                } 
            }
 
            if (HasIndirectLocationInputs) {
                foreach (SectionInput input in IndirectLocationInputs) {
                    ErrorsHelper.AddErrors(ref allErrors, input.Errors);
                } 
            }
 
            if (HasFileInput) { 
                ErrorsHelper.AddErrors(ref allErrors, FileInput.Errors);
            } 

            return allErrors;
        }
 
        internal bool HasErrors {
            get { 
                if (ErrorsHelper.GetHasErrors(_errors)) { 
                    return true;
                } 

                if (HasLocationInputs) {
                    foreach (SectionInput input in LocationInputs) {
                        if (input.HasErrors) { 
                            return true;
                        } 
                    } 
                }
 
                if (HasIndirectLocationInputs) {
                    foreach (SectionInput input in IndirectLocationInputs) {
                        if (input.HasErrors) {
                            return true; 
                        }
                    } 
                } 

                if (HasFileInput) { 
                    if (FileInput.HasErrors) {
                        return true;
                    }
                } 

                return false; 
            } 
        }
 
        internal void ThrowOnErrors() {
            if (HasErrors) {
                throw new ConfigurationErrorsException(GetAllErrors());
            } 
        }
    } 
} 


// 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