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

  1. //------------------------------------------------------------------------------
  2. // <copyright file="ConfigurationSectionGroup.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;
  18.     using System.Configuration.Internal;
  19.    
  20.     public class ConfigurationSectionGroup
  21.     {
  22.         string _configKey = String.Empty;
  23.         string _group = String.Empty;
  24.         string _name = String.Empty;
  25.         ConfigurationSectionCollection _configSections;
  26.         ConfigurationSectionGroupCollection _configSectionGroups;
  27.         MgmtConfigurationRecord _configRecord;
  28.         string _typeName;
  29.         bool _declared;
  30.         bool _declarationRequired;
  31.         bool _isRoot;
  32.        
  33.        
  34.         public ConfigurationSectionGroup()
  35.         {
  36.         }
  37.        
  38.         internal void AttachToConfigurationRecord(MgmtConfigurationRecord configRecord, FactoryRecord factoryRecord)
  39.         {
  40.             _configRecord = configRecord;
  41.             _configKey = factoryRecord.ConfigKey;
  42.             _group = factoryRecord.Group;
  43.             _name = factoryRecord.Name;
  44.             _typeName = factoryRecord.FactoryTypeName;
  45.            
  46.             if (_typeName != null) {
  47.                 FactoryRecord parentFactoryRecord = null;
  48.                 if (!configRecord.Parent.IsRootConfig) {
  49.                     parentFactoryRecord = configRecord.Parent.FindFactoryRecord(factoryRecord.ConfigKey, true);
  50.                 }
  51.                
  52.                 _declarationRequired = (parentFactoryRecord == null || parentFactoryRecord.FactoryTypeName == null);
  53.                 _declared = configRecord.GetFactoryRecord(factoryRecord.ConfigKey, true) != null;
  54.             }
  55.         }
  56.        
  57.         internal void RootAttachToConfigurationRecord(MgmtConfigurationRecord configRecord)
  58.         {
  59.             _configRecord = configRecord;
  60.            
  61.             _isRoot = true;
  62.         }
  63.        
  64.         internal void DetachFromConfigurationRecord()
  65.         {
  66.             if (_configSections != null) {
  67.                 _configSections.DetachFromConfigurationRecord();
  68.             }
  69.            
  70.             if (_configSectionGroups != null) {
  71.                 _configSectionGroups.DetachFromConfigurationRecord();
  72.             }
  73.            
  74.             _configRecord = null;
  75.         }
  76.        
  77.         internal bool Attached {
  78.             get { return _configRecord != null; }
  79.         }
  80.        
  81.         private FactoryRecord FindParentFactoryRecord(bool permitErrors)
  82.         {
  83.             FactoryRecord factoryRecord = null;
  84.            
  85.             if (_configRecord != null && !_configRecord.Parent.IsRootConfig) {
  86.                 factoryRecord = _configRecord.Parent.FindFactoryRecord(_configKey, permitErrors);
  87.             }
  88.            
  89.             return factoryRecord;
  90.         }
  91.        
  92.         private void VerifyIsAttachedToConfigRecord()
  93.         {
  94.             if (_configRecord == null) {
  95.                 throw new InvalidOperationException(SR.GetString(SR.Config_cannot_edit_configurationsectiongroup_when_not_attached));
  96.             }
  97.         }
  98.        
  99.         // IsDeclared
  100.         //
  101.         // Is the Declaration in this config file?
  102.         //
  103.         public bool IsDeclared {
  104.             get { return _declared; }
  105.         }
  106.        
  107.         // IsDeclarationRequired
  108.         //
  109.         // Is the Declaration Required. It is required if it is not set
  110.         // int a parent, or the parent entry does not have the type
  111.         //
  112.         public bool IsDeclarationRequired {
  113.             get { return _declarationRequired; }
  114.         }
  115.        
  116.         // ForceDeclaration
  117.         //
  118.         // Force the declaration to be written.
  119.         //
  120.         public void ForceDeclaration()
  121.         {
  122.             ForceDeclaration(true);
  123.         }
  124.        
  125.         // ForceDeclaration
  126.         //
  127.         // Force the declaration to be written. If this is false, it
  128.         // may be ignored depending on if it is Required
  129.         //
  130.         public void ForceDeclaration(bool force)
  131.         {
  132.             if (_isRoot) {
  133.                 throw new InvalidOperationException(SR.GetString(SR.Config_root_section_group_cannot_be_edited));
  134.             }
  135.            
  136.             if (_configRecord != null && _configRecord.IsLocationConfig) {
  137.                 throw new InvalidOperationException(SR.GetString(SR.Config_cannot_edit_configurationsectiongroup_in_location_config));
  138.             }
  139.            
  140.             if (!force && _declarationRequired) {
  141.                 // Since it is required, we can not remove it
  142.             }
  143.             else {
  144.                 _declared = force;
  145.             }
  146.         }
  147.        
  148.         public string SectionGroupName {
  149.             get { return _configKey; }
  150.         }
  151.        
  152.         public string Name {
  153.             get { return _name; }
  154.         }
  155.        
  156.         public string Type {
  157.             get { return _typeName; }
  158.             set {
  159.                 if (_isRoot) {
  160.                     throw new InvalidOperationException(SR.GetString(SR.Config_root_section_group_cannot_be_edited));
  161.                 }
  162.                
  163.                 // Since type is optional for a section group, allow it to be removed.
  164.                 // Note that a typename of "" is not permitted in the config file.
  165.                 string typeName = value;
  166.                 if (String.IsNullOrEmpty(typeName)) {
  167.                     typeName = null;
  168.                 }
  169.                
  170.                 if (_configRecord != null) {
  171.                     if (_configRecord.IsLocationConfig) {
  172.                         throw new InvalidOperationException(SR.GetString(SR.Config_cannot_edit_configurationsectiongroup_in_location_config));
  173.                     }
  174.                    
  175.                     // allow type to be different from current type,
  176.                     // so long as it doesn't conflict with a type already defined
  177.                     if (typeName != null) {
  178.                         FactoryRecord factoryRecord = FindParentFactoryRecord(false);
  179.                         if (factoryRecord != null && !factoryRecord.IsEquivalentType(_configRecord.Host, typeName)) {
  180.                             throw new ConfigurationErrorsException(SR.GetString(SR.Config_tag_name_already_defined, _configKey));
  181.                         }
  182.                     }
  183.                 }
  184.                
  185.                 _typeName = typeName;
  186.             }
  187.         }
  188.        
  189.         public ConfigurationSectionCollection Sections {
  190.             get {
  191.                 if (_configSections == null) {
  192.                     VerifyIsAttachedToConfigRecord();
  193.                     _configSections = new ConfigurationSectionCollection(_configRecord, this);
  194.                 }
  195.                
  196.                 return _configSections;
  197.             }
  198.         }
  199.        
  200.         public ConfigurationSectionGroupCollection SectionGroups {
  201.             get {
  202.                 if (_configSectionGroups == null) {
  203.                     VerifyIsAttachedToConfigRecord();
  204.                     _configSectionGroups = new ConfigurationSectionGroupCollection(_configRecord, this);
  205.                 }
  206.                
  207.                 return _configSectionGroups;
  208.             }
  209.         }
  210.        
  211.         internal bool IsRoot {
  212.             get { return _isRoot; }
  213.         }
  214.        
  215.     }
  216. }

Developer Fusion