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

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

Developer Fusion