The Labs \ Source Viewer \ SSCLI \ System.Configuration \ ConfigurationSectionCollection

  1. //------------------------------------------------------------------------------
  2. // <copyright file="ConfigurationSectionCollection.cs" company="Microsoft">
  3. //
  4. // Copyright (c) 2006 Microsoft Corporation. All rights reserved.
  5. //
  6. // The use and distribution terms for this software are contained in the file
  7. // named license.txt, which can be found in the root of this distribution.
  8. // By using this software in any fashion, you are agreeing to be bound by the
  9. // terms of this license.
  10. //
  11. // You must not remove this notice, or any other, from this software.
  12. //
  13. // </copyright>
  14. //------------------------------------------------------------------------------
  15. namespace System.Configuration
  16. {
  17.     using System.Collections;
  18.     using System.Collections.Specialized;
  19.     using System.Runtime.Serialization;
  20.     using System.Security.Permissions;
  21.    
  22.     [Serializable()]
  23.     public sealed class ConfigurationSectionCollection : NameObjectCollectionBase
  24.     {
  25.        
  26.         private MgmtConfigurationRecord _configRecord;
  27.         private ConfigurationSectionGroup _configSectionGroup;
  28.        
  29.         //
  30.         // Create the collection of all sections in the section group.
  31.         //
  32.         internal ConfigurationSectionCollection(MgmtConfigurationRecord configRecord, ConfigurationSectionGroup configSectionGroup) : base(StringComparer.Ordinal)
  33.         {
  34.            
  35.             _configRecord = configRecord;
  36.             _configSectionGroup = configSectionGroup;
  37.            
  38.             foreach (DictionaryEntry de in _configRecord.SectionFactories) {
  39.                 FactoryId factoryId = (FactoryId)de.Value;
  40.                 if (factoryId.Group == _configSectionGroup.SectionGroupName) {
  41.                     BaseAdd(factoryId.Name, factoryId.Name);
  42.                 }
  43.             }
  44.         }
  45.        
  46.         [SecurityPermissionAttribute(SecurityAction.Demand, SerializationFormatter = true)]
  47.         public override void GetObjectData(SerializationInfo info, StreamingContext context)
  48.         {
  49.             base.GetObjectData(info, context);
  50.         }
  51.        
  52.         //
  53.         // Remove the collection from configuration system, and remove all entries
  54.         // in the base collection so that enumeration will return an empty collection.
  55.         //
  56.         internal void DetachFromConfigurationRecord()
  57.         {
  58.             _configRecord = null;
  59.             BaseClear();
  60.         }
  61.        
  62.         private void VerifyIsAttachedToConfigRecord()
  63.         {
  64.             if (_configRecord == null) {
  65.                 throw new InvalidOperationException(SR.GetString(SR.Config_cannot_edit_configurationsectiongroup_when_not_attached));
  66.             }
  67.         }
  68.        
  69.         //
  70.         // Public Properties
  71.         //
  72.        
  73.         // Indexer via name
  74.         public ConfigurationSection this[string name]
  75.         {
  76.             get { return Get(name); }
  77.         }
  78.        
  79.         // Indexer via integer index.
  80.         public ConfigurationSection this[int index]
  81.         {
  82.             get { return Get(index); }
  83.         }
  84.        
  85.         //
  86.         // Public methods
  87.         //
  88.        
  89.         //
  90.         // Add a new section to the collection. This will result in a new declaration and definition.
  91.         //
  92.         // It is an error if the section already exists.
  93.         //
  94.         public void Add(string name, ConfigurationSection section)
  95.         {
  96.             VerifyIsAttachedToConfigRecord();
  97.            
  98.             _configRecord.AddConfigurationSection(_configSectionGroup.SectionGroupName, name, section);
  99.             BaseAdd(name, name);
  100.         }
  101.        
  102.         //
  103.         // Remove all sections from the collection.
  104.         //
  105.         public void Clear()
  106.         {
  107.             VerifyIsAttachedToConfigRecord();
  108.            
  109.             string[] allKeys = BaseGetAllKeys();
  110.             foreach (string key in allKeys) {
  111.                 Remove(key);
  112.             }
  113.         }
  114.        
  115.         //
  116.         // Return the number of sections in the collection.
  117.         //
  118.         public override int Count {
  119.             get { return base.Count; }
  120.         }
  121.        
  122.         //
  123.         // Copy all the sections to an array.
  124.         //
  125.         public void CopyTo(ConfigurationSection[] array, int index)
  126.         {
  127.             if (array == null) {
  128.                 throw new ArgumentNullException("array");
  129.             }
  130.            
  131.             int c = Count;
  132.             if (array.Length < c + index) {
  133.                 throw new ArgumentOutOfRangeException("index");
  134.             }
  135.            
  136.             for (int i = 0int j = index; i < c; i++,j++) {
  137.                 array[j] = Get(i);
  138.             }
  139.         }
  140.        
  141.         //
  142.         // Get the section at a given index.
  143.         //
  144.         public ConfigurationSection Get(int index)
  145.         {
  146.             return Get(GetKey(index));
  147.         }
  148.        
  149.         //
  150.         // Get the section with a given name.
  151.         //
  152.         public ConfigurationSection Get(string name)
  153.         {
  154.             VerifyIsAttachedToConfigRecord();
  155.            
  156.             // validate name
  157.             if (String.IsNullOrEmpty(name))
  158.                 throw ExceptionUtil.ParameterNullOrEmpty("name");
  159.            
  160.             // prevent GetConfig from returning config not in this collection
  161.             if (name.IndexOf('/') >= 0)
  162.                 return null;
  163.            
  164.             // get the section from the config record
  165.             string configKey = BaseConfigurationRecord.CombineConfigKey(_configSectionGroup.SectionGroupName, name);
  166.             return (ConfigurationSection)_configRecord.GetSection(configKey);
  167.         }
  168.        
  169.         // Get an enumerator
  170.         public override IEnumerator GetEnumerator()
  171.         {
  172.             int c = Count;
  173.             for (int i = 0; i < c; i++) {
  174.                 yield return this[i];
  175.             }
  176.         }
  177.        
  178.         // Get the string key at a given index.
  179.         public string GetKey(int index)
  180.         {
  181.             return BaseGetKey(index);
  182.         }
  183.        
  184.         // Return the string keys of the collection.
  185.         public override KeysCollection Keys {
  186.             get { return base.Keys; }
  187.         }
  188.        
  189.         //
  190.         // Remove the declaration and definition of a section in this config file, including any
  191.         // location sections in the file.
  192.         //
  193.         // Note that if the section is declared in a parent, we still remove the declaration and
  194.         // definition, and the instance of ConfigurationSection will be detached from the collection.
  195.         // However, the collection will still have a ConfigurationSection of that name in the collection,
  196.         // only it will have the value of the immediate parent.
  197.         //
  198.         public void Remove(string name)
  199.         {
  200.             VerifyIsAttachedToConfigRecord();
  201.            
  202.             //
  203.             // Remove the factory and section from this record, so that when config is written,
  204.             // it will contain neither a declaration or definition.
  205.             //
  206.             _configRecord.RemoveConfigurationSection(_configSectionGroup.SectionGroupName, name);
  207.            
  208.             //
  209.             // Remove the section from the collection if it is no longer in the list of all SectionFactories.
  210.             //
  211.             string configKey = BaseConfigurationRecord.CombineConfigKey(_configSectionGroup.SectionGroupName, name);
  212.             if (!_configRecord.SectionFactories.Contains(configKey)) {
  213.                 BaseRemove(name);
  214.             }
  215.         }
  216.        
  217.         //
  218.         // Remove the section at that index.
  219.         //
  220.         public void RemoveAt(int index)
  221.         {
  222.             VerifyIsAttachedToConfigRecord();
  223.            
  224.             Remove(GetKey(index));
  225.         }
  226.     }
  227. }

Developer Fusion