ConfigurationLockCollection.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ Net / Net / 3.5.50727.3053 / DEVDIV / depot / DevDiv / releases / whidbey / netfxsp / ndp / fx / src / Configuration / System / Configuration / ConfigurationLockCollection.cs / 1 / ConfigurationLockCollection.cs

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

using System; 
using System.Configuration.Internal; 
using System.Collections;
using System.Collections.Specialized; 
using System.Collections.Generic;
using System.IO;
using System.Reflection;
using System.Security.Permissions; 
using System.Xml;
using System.Globalization; 
using System.ComponentModel; 
using System.Security;
using System.Text; 

namespace System.Configuration {

    public sealed class ConfigurationLockCollection : IEnumerable, ICollection { 
        private HybridDictionary internalDictionary;
        private ArrayList internalArraylist; 
        private bool _bModified = false; 
        private bool _bExceptionList = false;
        private string _ignoreName = String.Empty; 
        private ConfigurationElement _thisElement = null;
        private ConfigurationLockCollectionType _lockType;
        private string SeedList = String.Empty;
        private const string LockAll = "*"; 

        internal ConfigurationLockCollection(ConfigurationElement thisElement) 
            : this(thisElement, ConfigurationLockCollectionType.LockedAttributes) { 
        }
 
        internal ConfigurationLockCollection(ConfigurationElement thisElement, ConfigurationLockCollectionType lockType)
            : this(thisElement, lockType, String.Empty) {
        }
 
        internal ConfigurationLockCollection(ConfigurationElement thisElement, ConfigurationLockCollectionType lockType, string ignoreName)
            : this(thisElement, lockType, ignoreName, null) { 
        } 

        internal ConfigurationLockCollection(ConfigurationElement thisElement, ConfigurationLockCollectionType lockType, 
                    string ignoreName, ConfigurationLockCollection parentCollection) {
            _thisElement = thisElement;
            _lockType = lockType;
            internalDictionary = new HybridDictionary(); 
            internalArraylist = new ArrayList();
            _bModified = false; 
 
            _bExceptionList = _lockType == ConfigurationLockCollectionType.LockedExceptionList ||
                              _lockType == ConfigurationLockCollectionType.LockedElementsExceptionList; 
            _ignoreName = ignoreName;

            if (parentCollection != null) {
                foreach (string key in parentCollection) // seed the new collection 
                {
                    Add(key, ConfigurationValueFlags.Inherited);  // add the local copy 
                    if (_bExceptionList) { 
                        if (SeedList.Length != 0)
                            SeedList += ","; 
                        SeedList += key;
                    }
                }
            } 

        } 
 
        internal void ClearSeedList()
        { 
            SeedList = String.Empty;
        }

        internal ConfigurationLockCollectionType LockType { 
            get { return _lockType; }
        } 
 
        public void Add(string name) {
 
            if (((_thisElement.ItemLocked & ConfigurationValueFlags.Locked) != 0) &&
                ((_thisElement.ItemLocked & ConfigurationValueFlags.Inherited) != 0)) {
                throw new ConfigurationErrorsException(SR.GetString(SR.Config_base_attribute_locked, name));
            } 

            ConfigurationValueFlags flags = ConfigurationValueFlags.Modified; 
 
            string attribToLockTrim = name.Trim();
            ConfigurationProperty propToLock = _thisElement.Properties[attribToLockTrim]; 
            if (propToLock == null && attribToLockTrim != LockAll) {
                ConfigurationElementCollection collection = _thisElement as ConfigurationElementCollection;
                if (collection == null && _thisElement.Properties.DefaultCollectionProperty != null) { // this is not a collection but it may contain a default collection
                    collection = _thisElement[_thisElement.Properties.DefaultCollectionProperty] as ConfigurationElementCollection; 
                }
 
                if (collection == null || 
                    _lockType == ConfigurationLockCollectionType.LockedAttributes || // If the collection type is not element then the lock is bogus
                    _lockType == ConfigurationLockCollectionType.LockedExceptionList) { 
                    _thisElement.ReportInvalidLock(attribToLockTrim, _lockType, null, null);
                }
                else if (!collection.IsLockableElement(attribToLockTrim)) {
                    _thisElement.ReportInvalidLock(attribToLockTrim, _lockType, null, collection.LockableElements); 
                }
            } 
            else { // the lock is in the property bag but is it the correct type? 
                if (propToLock != null && propToLock.IsRequired)
                    throw new ConfigurationErrorsException(SR.GetString(SR.Config_base_required_attribute_lock_attempt, propToLock.Name)); 

                if (attribToLockTrim != LockAll) {
                    if ((_lockType == ConfigurationLockCollectionType.LockedElements) ||
                         (_lockType == ConfigurationLockCollectionType.LockedElementsExceptionList)) { 
                        // If it is an element then it must be derived from ConfigurationElement
                        if (!typeof(ConfigurationElement).IsAssignableFrom(propToLock.Type)) { 
                            _thisElement.ReportInvalidLock(attribToLockTrim, _lockType, null, null); 
                        }
                    } 
                    else {
                        // if it is a property then it cannot be derived from ConfigurationElement
                        if (typeof(ConfigurationElement).IsAssignableFrom(propToLock.Type)) {
                            _thisElement.ReportInvalidLock(attribToLockTrim, _lockType, null, null); 
                        }
                    } 
                } 
            }
 
            if (internalDictionary.Contains(name)) {
                flags = ConfigurationValueFlags.Modified | (ConfigurationValueFlags)internalDictionary[name];
                internalDictionary.Remove(name); // not from parent
                internalArraylist.Remove(name); 
            }
            internalDictionary.Add(name, flags); // not from parent 
            internalArraylist.Add(name); 
            _bModified = true;
        } 


        internal void Add(string name, ConfigurationValueFlags flags) {
            if ((flags != ConfigurationValueFlags.Inherited) && (internalDictionary.Contains(name))) { 
                // the user has an item declared as locked below a level where it is already locked
                // keep enough info so we can write out the lock if they save in modified mode 
                flags = ConfigurationValueFlags.Modified | (ConfigurationValueFlags)internalDictionary[name]; 
                internalDictionary.Remove(name);
                internalArraylist.Remove(name); 
            }

            internalDictionary.Add(name, flags); // not from parent
            internalArraylist.Add(name); 
        }
 
        internal bool DefinedInParent(string name) { 
            if (name == null)
                return false; 
            if (_bExceptionList)
            {
                string ParentListEnclosed = "," + SeedList + ",";
                if (name.Equals(_ignoreName) || ParentListEnclosed.IndexOf("," + name + ",", StringComparison.Ordinal) >= 0) { 
                    return true;
                } 
            } 
            return (internalDictionary.Contains(name) &&
                ((ConfigurationValueFlags)internalDictionary[name] & ConfigurationValueFlags.Inherited) != 0); 
        }

        internal bool IsValueModified(string name) {
            return (internalDictionary.Contains(name) && 
                ((ConfigurationValueFlags)internalDictionary[name] & ConfigurationValueFlags.Modified) != 0);
        } 
 
        internal void RemoveInheritedLocks() {
            StringCollection removeList = new StringCollection(); 
            foreach (string key in this) {
                if (DefinedInParent(key)) {
                    removeList.Add(key);
                } 
            }
            foreach (string key in removeList) { 
                internalDictionary.Remove(key); 
                internalArraylist.Remove(key);
            } 
        }


        public void Remove(string name) { 
            if (!internalDictionary.Contains(name)) {
                throw new ConfigurationErrorsException(SR.GetString(SR.Config_base_collection_entry_not_found, name)); 
            } 
            // in a locked list you cannot remove items that were locked in the parent
            // in an exception list this is legal because it makes the list more restrictive 

            if (_bExceptionList == false &&
                ((ConfigurationValueFlags)internalDictionary[name] & ConfigurationValueFlags.Inherited) != 0) {
                if (((ConfigurationValueFlags)internalDictionary[name] & ConfigurationValueFlags.Modified) != 0) { 
                    // allow the local one to be "removed" so it won't write out but throw if they try and remove
                    // one that is only inherited 
                    ConfigurationValueFlags flags = (ConfigurationValueFlags)internalDictionary[name]; 
                    flags &= ~ConfigurationValueFlags.Modified;
                    internalDictionary[name] = flags; 
                    _bModified = true;
                    return;
                }
                else { 
                    throw new ConfigurationErrorsException(SR.GetString(SR.Config_base_attribute_locked, name));
                } 
            } 

            internalDictionary.Remove(name); 
            internalArraylist.Remove(name);
            _bModified = true;
        }
 
        public IEnumerator GetEnumerator() {
            return internalArraylist.GetEnumerator(); 
        } 

        internal void ClearInternal(bool useSeedIfAvailble) { 
            ArrayList removeList = new ArrayList();
            foreach (DictionaryEntry de in internalDictionary) {
                if ((((ConfigurationValueFlags)de.Value & ConfigurationValueFlags.Inherited) == 0)
                    || _bExceptionList == true) { 
                    removeList.Add(de.Key);
                } 
            } 
            foreach (object removeKey in removeList) {
                internalDictionary.Remove(removeKey); 
                internalArraylist.Remove(removeKey);
            }

            // Clearing an Exception list really means revert to parent 
            if (useSeedIfAvailble && !String.IsNullOrEmpty(SeedList)) {
                string[] Keys = SeedList.Split(new char[] { ',' }); 
                foreach (string key in Keys) { 
                    Add(key, ConfigurationValueFlags.Inherited); //
                } 
            }
            _bModified = true;
        }
 
        public void Clear() {
            ClearInternal(true); 
        } 

        public bool Contains(string name) { 
            if (_bExceptionList && name.Equals(_ignoreName)) {
                return true;
            }
            return internalDictionary.Contains(name); 
        }
 
        public int Count { 
            get {
                return internalDictionary.Count; 
            }
        }

        public bool IsSynchronized { 
            get {
                return false; 
            } 
        }
 
        public object SyncRoot {
            get {
                return this;
            } 
        }
 
        public void CopyTo(string[] array, int index) { 
            ((ICollection)this).CopyTo(array, index);
        } 

        void ICollection.CopyTo(Array array, int index) {
            internalArraylist.CopyTo(array, index);
        } 

        public bool IsModified { 
            get { 
                return _bModified;
            } 
        }

        internal void ResetModified() {
            _bModified = false; 
        }
 
        public bool IsReadOnly(string name) { 
            if (!internalDictionary.Contains(name)) {
                throw new ConfigurationErrorsException(SR.GetString(SR.Config_base_collection_entry_not_found, name)); 
            }
            return (bool)(((ConfigurationValueFlags)internalDictionary[name] & ConfigurationValueFlags.Inherited) != 0);
        }
 
        internal bool ExceptionList {
            get { 
                return _bExceptionList; 
            }
        } 

        public string AttributeList {
            get {
                StringBuilder sb; 
                sb = new StringBuilder();
 
                foreach (DictionaryEntry de in internalDictionary) { 
                    if (sb.Length != 0) {
                        sb.Append(','); 
                    }
                    sb.Append(de.Key);
                }
                return sb.ToString(); 
            }
        } 
 
        public void SetFromList(string attributeList) {
            string[] splits = attributeList.Split(new char[] { ',', ';', ':' }); 
            Clear();
            foreach (string name in splits) {
                string attribTrim = name.Trim();
                if (!Contains(attribTrim)) { 
                    Add(attribTrim);
                } 
            } 
        }
        public bool HasParentElements { 
            get {
                // return true if there is at least one element that was defined in the parent
                bool result = false;
                // Check to see if the exception list is empty as a result of a merge from config 
                // If so the there were some parent elements because empty string is invalid in config.
                // and the only way to get an empty list is for the merged config to have no elements 
                // in common. 
                if (ExceptionList && internalDictionary.Count == 0 && !String.IsNullOrEmpty(SeedList))
                    return true; 

                foreach (DictionaryEntry de in internalDictionary) {
                    if ((bool)(((ConfigurationValueFlags)de.Value & ConfigurationValueFlags.Inherited) != 0)) {
                        result = true; 
                        break;
                    } 
                } 

                return result; 
            }
        }
    }
} 

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

using System; 
using System.Configuration.Internal; 
using System.Collections;
using System.Collections.Specialized; 
using System.Collections.Generic;
using System.IO;
using System.Reflection;
using System.Security.Permissions; 
using System.Xml;
using System.Globalization; 
using System.ComponentModel; 
using System.Security;
using System.Text; 

namespace System.Configuration {

    public sealed class ConfigurationLockCollection : IEnumerable, ICollection { 
        private HybridDictionary internalDictionary;
        private ArrayList internalArraylist; 
        private bool _bModified = false; 
        private bool _bExceptionList = false;
        private string _ignoreName = String.Empty; 
        private ConfigurationElement _thisElement = null;
        private ConfigurationLockCollectionType _lockType;
        private string SeedList = String.Empty;
        private const string LockAll = "*"; 

        internal ConfigurationLockCollection(ConfigurationElement thisElement) 
            : this(thisElement, ConfigurationLockCollectionType.LockedAttributes) { 
        }
 
        internal ConfigurationLockCollection(ConfigurationElement thisElement, ConfigurationLockCollectionType lockType)
            : this(thisElement, lockType, String.Empty) {
        }
 
        internal ConfigurationLockCollection(ConfigurationElement thisElement, ConfigurationLockCollectionType lockType, string ignoreName)
            : this(thisElement, lockType, ignoreName, null) { 
        } 

        internal ConfigurationLockCollection(ConfigurationElement thisElement, ConfigurationLockCollectionType lockType, 
                    string ignoreName, ConfigurationLockCollection parentCollection) {
            _thisElement = thisElement;
            _lockType = lockType;
            internalDictionary = new HybridDictionary(); 
            internalArraylist = new ArrayList();
            _bModified = false; 
 
            _bExceptionList = _lockType == ConfigurationLockCollectionType.LockedExceptionList ||
                              _lockType == ConfigurationLockCollectionType.LockedElementsExceptionList; 
            _ignoreName = ignoreName;

            if (parentCollection != null) {
                foreach (string key in parentCollection) // seed the new collection 
                {
                    Add(key, ConfigurationValueFlags.Inherited);  // add the local copy 
                    if (_bExceptionList) { 
                        if (SeedList.Length != 0)
                            SeedList += ","; 
                        SeedList += key;
                    }
                }
            } 

        } 
 
        internal void ClearSeedList()
        { 
            SeedList = String.Empty;
        }

        internal ConfigurationLockCollectionType LockType { 
            get { return _lockType; }
        } 
 
        public void Add(string name) {
 
            if (((_thisElement.ItemLocked & ConfigurationValueFlags.Locked) != 0) &&
                ((_thisElement.ItemLocked & ConfigurationValueFlags.Inherited) != 0)) {
                throw new ConfigurationErrorsException(SR.GetString(SR.Config_base_attribute_locked, name));
            } 

            ConfigurationValueFlags flags = ConfigurationValueFlags.Modified; 
 
            string attribToLockTrim = name.Trim();
            ConfigurationProperty propToLock = _thisElement.Properties[attribToLockTrim]; 
            if (propToLock == null && attribToLockTrim != LockAll) {
                ConfigurationElementCollection collection = _thisElement as ConfigurationElementCollection;
                if (collection == null && _thisElement.Properties.DefaultCollectionProperty != null) { // this is not a collection but it may contain a default collection
                    collection = _thisElement[_thisElement.Properties.DefaultCollectionProperty] as ConfigurationElementCollection; 
                }
 
                if (collection == null || 
                    _lockType == ConfigurationLockCollectionType.LockedAttributes || // If the collection type is not element then the lock is bogus
                    _lockType == ConfigurationLockCollectionType.LockedExceptionList) { 
                    _thisElement.ReportInvalidLock(attribToLockTrim, _lockType, null, null);
                }
                else if (!collection.IsLockableElement(attribToLockTrim)) {
                    _thisElement.ReportInvalidLock(attribToLockTrim, _lockType, null, collection.LockableElements); 
                }
            } 
            else { // the lock is in the property bag but is it the correct type? 
                if (propToLock != null && propToLock.IsRequired)
                    throw new ConfigurationErrorsException(SR.GetString(SR.Config_base_required_attribute_lock_attempt, propToLock.Name)); 

                if (attribToLockTrim != LockAll) {
                    if ((_lockType == ConfigurationLockCollectionType.LockedElements) ||
                         (_lockType == ConfigurationLockCollectionType.LockedElementsExceptionList)) { 
                        // If it is an element then it must be derived from ConfigurationElement
                        if (!typeof(ConfigurationElement).IsAssignableFrom(propToLock.Type)) { 
                            _thisElement.ReportInvalidLock(attribToLockTrim, _lockType, null, null); 
                        }
                    } 
                    else {
                        // if it is a property then it cannot be derived from ConfigurationElement
                        if (typeof(ConfigurationElement).IsAssignableFrom(propToLock.Type)) {
                            _thisElement.ReportInvalidLock(attribToLockTrim, _lockType, null, null); 
                        }
                    } 
                } 
            }
 
            if (internalDictionary.Contains(name)) {
                flags = ConfigurationValueFlags.Modified | (ConfigurationValueFlags)internalDictionary[name];
                internalDictionary.Remove(name); // not from parent
                internalArraylist.Remove(name); 
            }
            internalDictionary.Add(name, flags); // not from parent 
            internalArraylist.Add(name); 
            _bModified = true;
        } 


        internal void Add(string name, ConfigurationValueFlags flags) {
            if ((flags != ConfigurationValueFlags.Inherited) && (internalDictionary.Contains(name))) { 
                // the user has an item declared as locked below a level where it is already locked
                // keep enough info so we can write out the lock if they save in modified mode 
                flags = ConfigurationValueFlags.Modified | (ConfigurationValueFlags)internalDictionary[name]; 
                internalDictionary.Remove(name);
                internalArraylist.Remove(name); 
            }

            internalDictionary.Add(name, flags); // not from parent
            internalArraylist.Add(name); 
        }
 
        internal bool DefinedInParent(string name) { 
            if (name == null)
                return false; 
            if (_bExceptionList)
            {
                string ParentListEnclosed = "," + SeedList + ",";
                if (name.Equals(_ignoreName) || ParentListEnclosed.IndexOf("," + name + ",", StringComparison.Ordinal) >= 0) { 
                    return true;
                } 
            } 
            return (internalDictionary.Contains(name) &&
                ((ConfigurationValueFlags)internalDictionary[name] & ConfigurationValueFlags.Inherited) != 0); 
        }

        internal bool IsValueModified(string name) {
            return (internalDictionary.Contains(name) && 
                ((ConfigurationValueFlags)internalDictionary[name] & ConfigurationValueFlags.Modified) != 0);
        } 
 
        internal void RemoveInheritedLocks() {
            StringCollection removeList = new StringCollection(); 
            foreach (string key in this) {
                if (DefinedInParent(key)) {
                    removeList.Add(key);
                } 
            }
            foreach (string key in removeList) { 
                internalDictionary.Remove(key); 
                internalArraylist.Remove(key);
            } 
        }


        public void Remove(string name) { 
            if (!internalDictionary.Contains(name)) {
                throw new ConfigurationErrorsException(SR.GetString(SR.Config_base_collection_entry_not_found, name)); 
            } 
            // in a locked list you cannot remove items that were locked in the parent
            // in an exception list this is legal because it makes the list more restrictive 

            if (_bExceptionList == false &&
                ((ConfigurationValueFlags)internalDictionary[name] & ConfigurationValueFlags.Inherited) != 0) {
                if (((ConfigurationValueFlags)internalDictionary[name] & ConfigurationValueFlags.Modified) != 0) { 
                    // allow the local one to be "removed" so it won't write out but throw if they try and remove
                    // one that is only inherited 
                    ConfigurationValueFlags flags = (ConfigurationValueFlags)internalDictionary[name]; 
                    flags &= ~ConfigurationValueFlags.Modified;
                    internalDictionary[name] = flags; 
                    _bModified = true;
                    return;
                }
                else { 
                    throw new ConfigurationErrorsException(SR.GetString(SR.Config_base_attribute_locked, name));
                } 
            } 

            internalDictionary.Remove(name); 
            internalArraylist.Remove(name);
            _bModified = true;
        }
 
        public IEnumerator GetEnumerator() {
            return internalArraylist.GetEnumerator(); 
        } 

        internal void ClearInternal(bool useSeedIfAvailble) { 
            ArrayList removeList = new ArrayList();
            foreach (DictionaryEntry de in internalDictionary) {
                if ((((ConfigurationValueFlags)de.Value & ConfigurationValueFlags.Inherited) == 0)
                    || _bExceptionList == true) { 
                    removeList.Add(de.Key);
                } 
            } 
            foreach (object removeKey in removeList) {
                internalDictionary.Remove(removeKey); 
                internalArraylist.Remove(removeKey);
            }

            // Clearing an Exception list really means revert to parent 
            if (useSeedIfAvailble && !String.IsNullOrEmpty(SeedList)) {
                string[] Keys = SeedList.Split(new char[] { ',' }); 
                foreach (string key in Keys) { 
                    Add(key, ConfigurationValueFlags.Inherited); //
                } 
            }
            _bModified = true;
        }
 
        public void Clear() {
            ClearInternal(true); 
        } 

        public bool Contains(string name) { 
            if (_bExceptionList && name.Equals(_ignoreName)) {
                return true;
            }
            return internalDictionary.Contains(name); 
        }
 
        public int Count { 
            get {
                return internalDictionary.Count; 
            }
        }

        public bool IsSynchronized { 
            get {
                return false; 
            } 
        }
 
        public object SyncRoot {
            get {
                return this;
            } 
        }
 
        public void CopyTo(string[] array, int index) { 
            ((ICollection)this).CopyTo(array, index);
        } 

        void ICollection.CopyTo(Array array, int index) {
            internalArraylist.CopyTo(array, index);
        } 

        public bool IsModified { 
            get { 
                return _bModified;
            } 
        }

        internal void ResetModified() {
            _bModified = false; 
        }
 
        public bool IsReadOnly(string name) { 
            if (!internalDictionary.Contains(name)) {
                throw new ConfigurationErrorsException(SR.GetString(SR.Config_base_collection_entry_not_found, name)); 
            }
            return (bool)(((ConfigurationValueFlags)internalDictionary[name] & ConfigurationValueFlags.Inherited) != 0);
        }
 
        internal bool ExceptionList {
            get { 
                return _bExceptionList; 
            }
        } 

        public string AttributeList {
            get {
                StringBuilder sb; 
                sb = new StringBuilder();
 
                foreach (DictionaryEntry de in internalDictionary) { 
                    if (sb.Length != 0) {
                        sb.Append(','); 
                    }
                    sb.Append(de.Key);
                }
                return sb.ToString(); 
            }
        } 
 
        public void SetFromList(string attributeList) {
            string[] splits = attributeList.Split(new char[] { ',', ';', ':' }); 
            Clear();
            foreach (string name in splits) {
                string attribTrim = name.Trim();
                if (!Contains(attribTrim)) { 
                    Add(attribTrim);
                } 
            } 
        }
        public bool HasParentElements { 
            get {
                // return true if there is at least one element that was defined in the parent
                bool result = false;
                // Check to see if the exception list is empty as a result of a merge from config 
                // If so the there were some parent elements because empty string is invalid in config.
                // and the only way to get an empty list is for the merged config to have no elements 
                // in common. 
                if (ExceptionList && internalDictionary.Count == 0 && !String.IsNullOrEmpty(SeedList))
                    return true; 

                foreach (DictionaryEntry de in internalDictionary) {
                    if ((bool)(((ConfigurationValueFlags)de.Value & ConfigurationValueFlags.Inherited) != 0)) {
                        result = true; 
                        break;
                    } 
                } 

                return result; 
            }
        }
    }
} 

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