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

  1. //------------------------------------------------------------------------------
  2. // <copyright file="ConfigurationValues.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. using System;
  16. using System.Configuration.Internal;
  17. using System.Collections;
  18. using System.Collections.Specialized;
  19. using System.Collections.Generic;
  20. using System.IO;
  21. using System.Reflection;
  22. using System.Security.Permissions;
  23. using System.Xml;
  24. using System.Globalization;
  25. using System.ComponentModel;
  26. using System.Security;
  27. using System.Text;
  28. namespace System.Configuration
  29. {
  30.    
  31.     internal class ConfigurationValues : NameObjectCollectionBase
  32.     {
  33.         private BaseConfigurationRecord _configRecord;
  34.         private bool _containsElement;
  35.         private bool _containsInvalidValue;
  36.        
  37.         internal ConfigurationValues() : base(StringComparer.Ordinal)
  38.         {
  39.         }
  40.        
  41.         // AssociateContext
  42.         //
  43.         // Associate a collection of values with a configRecord
  44.         //
  45.         internal void AssociateContext(BaseConfigurationRecord configRecord)
  46.         {
  47.             _configRecord = configRecord;
  48.            
  49.             // Associate with children
  50.             foreach (ConfigurationElement currentElement in ConfigurationElements) {
  51.                 currentElement.AssociateContext(_configRecord);
  52.             }
  53.         }
  54.        
  55.         internal bool Contains(string key)
  56.         {
  57.             return (BaseGet(key) != null);
  58.         }
  59.        
  60.         internal string GetKey(int index)
  61.         {
  62.             return BaseGetKey(index);
  63.         }
  64.        
  65. /*
  66.         internal ConfigurationValue GetConfigValue(int index)
  67.         {
  68.             return (ConfigurationValue)BaseGet(BaseGetKey(index));
  69.         }
  70.         */       
  71.        
  72.         internal ConfigurationValue GetConfigValue(string key)
  73.         {
  74.             return (ConfigurationValue)BaseGet(key);
  75.         }
  76.        
  77.         internal ConfigurationValue GetConfigValue(int index)
  78.         {
  79.             return (ConfigurationValue)BaseGet(index);
  80.         }
  81.        
  82.         internal PropertySourceInfo GetSourceInfo(string key)
  83.         {
  84.             ConfigurationValue configurationValue = GetConfigValue(key);
  85.             if (configurationValue != null) {
  86.                 return configurationValue.SourceInfo;
  87.             }
  88.             else {
  89.                 return null;
  90.             }
  91.         }
  92.        
  93.         internal void ChangeSourceInfo(string key, PropertySourceInfo sourceInfo)
  94.         {
  95.             ConfigurationValue configurationValue = GetConfigValue(key);
  96.             if (configurationValue != null) {
  97.                 configurationValue.SourceInfo = sourceInfo;
  98.             }
  99.         }
  100.        
  101.         private ConfigurationValue CreateConfigValue(object value, ConfigurationValueFlags valueFlags, PropertySourceInfo sourceInfo)
  102.         {
  103.             if (value != null) {
  104.                 if (value is ConfigurationElement) {
  105.                     _containsElement = true;
  106.                     ((ConfigurationElement)value).AssociateContext(_configRecord);
  107.                 }
  108.                 else if (value is InvalidPropValue) {
  109.                     _containsInvalidValue = true;
  110.                 }
  111.             }
  112.            
  113.             ConfigurationValue configValue = new ConfigurationValue(value, valueFlags, sourceInfo);
  114.             return configValue;
  115.         }
  116.        
  117.         internal void SetValue(string key, object value, ConfigurationValueFlags valueFlags, PropertySourceInfo sourceInfo)
  118.         {
  119.             ConfigurationValue configValue = CreateConfigValue(value, valueFlags, sourceInfo);
  120.             BaseSet(key, configValue);
  121.         }
  122.        
  123.        
  124.         internal object this[string key]
  125.         {
  126.             get {
  127.                 ConfigurationValue configValue = GetConfigValue(key);
  128.                 if (configValue != null) {
  129.                     return configValue.Value;
  130.                 }
  131.                 else {
  132.                     return null;
  133.                 }
  134.             }
  135.             set { SetValue(key, value, ConfigurationValueFlags.Modified, null); }
  136.         }
  137.        
  138.         internal object this[int index]
  139.         {
  140.             get {
  141.                 ConfigurationValue configValue = GetConfigValue(index);
  142.                 if (configValue != null) {
  143.                     return configValue.Value;
  144.                 }
  145.                 else {
  146.                     return null;
  147.                 }
  148.             }
  149.         }
  150.        
  151.        
  152.         internal void Clear()
  153.         {
  154.             BaseClear();
  155.         }
  156.        
  157.         internal object SyncRoot {
  158.             get { return this; }
  159.         }
  160.        
  161.         internal ConfigurationValueFlags RetrieveFlags(string key)
  162.         {
  163.             ConfigurationValue configurationValue = (ConfigurationValue)BaseGet(key);
  164.             if (configurationValue != null) {
  165.                 return configurationValue.ValueFlags;
  166.             }
  167.             else {
  168.                 return ConfigurationValueFlags.Default;
  169.             }
  170.         }
  171.        
  172.         internal bool IsModified(string key)
  173.         {
  174.             ConfigurationValue configurationValue = (ConfigurationValue)BaseGet(key);
  175.             if (configurationValue != null) {
  176.                 return ((configurationValue.ValueFlags & ConfigurationValueFlags.Modified) != 0);
  177.             }
  178.             else {
  179.                 return false;
  180.             }
  181.         }
  182.        
  183.         internal bool IsInherited(string key)
  184.         {
  185.             ConfigurationValue configurationValue = (ConfigurationValue)BaseGet(key);
  186.             if (configurationValue != null) {
  187.                 return ((configurationValue.ValueFlags & ConfigurationValueFlags.Inherited) != 0);
  188.             }
  189.             else {
  190.                 return false;
  191.             }
  192.            
  193.         }
  194.        
  195.         internal IEnumerable ConfigurationElements {
  196.             get {
  197.                 if (_containsElement) {
  198.                     return new ConfigurationElementsCollection(this);
  199.                 }
  200.                 else {
  201.                     return EmptyCollectionInstance;
  202.                 }
  203.             }
  204.         }
  205.        
  206.         internal IEnumerable InvalidValues {
  207.             get {
  208.                 if (_containsInvalidValue) {
  209.                     return new InvalidValuesCollection(this);
  210.                 }
  211.                 else {
  212.                     return EmptyCollectionInstance;
  213.                 }
  214.             }
  215.         }
  216.        
  217.         static IEnumerable s_emptyCollection;
  218.         static IEnumerable EmptyCollectionInstance {
  219.             get {
  220.                 if (s_emptyCollection == null) {
  221.                     s_emptyCollection = new EmptyCollection();
  222.                 }
  223.                
  224.                 return s_emptyCollection;
  225.             }
  226.         }
  227.        
  228.         private class EmptyCollection : IEnumerable
  229.         {
  230.             IEnumerator _emptyEnumerator;
  231.            
  232.             private class EmptyCollectionEnumerator : IEnumerator
  233.             {
  234.                 bool IEnumerator.MoveNext()
  235.                 {
  236.                     return false;
  237.                 }
  238.                
  239.                 object IEnumerator.Current {
  240.                     get { return null; }
  241.                 }
  242.                
  243.                 void IEnumerator.Reset()
  244.                 {
  245.                 }
  246.             }
  247.            
  248.             internal EmptyCollection()
  249.             {
  250.                 _emptyEnumerator = new EmptyCollectionEnumerator();
  251.             }
  252.            
  253.             IEnumerator IEnumerable.GetEnumerator()
  254.             {
  255.                 return _emptyEnumerator;
  256.             }
  257.         }
  258.        
  259.         private class ConfigurationElementsCollection : IEnumerable
  260.         {
  261.             ConfigurationValues _values;
  262.            
  263.             internal ConfigurationElementsCollection(ConfigurationValues values)
  264.             {
  265.                 _values = values;
  266.             }
  267.            
  268.             IEnumerator IEnumerable.GetEnumerator()
  269.             {
  270.                 if (_values._containsElement) {
  271.                     for (int index = 0; index < _values.Count; index++) {
  272.                         object value = _values[index];
  273.                         if (value is ConfigurationElement) {
  274.                             yield return value;
  275.                         }
  276.                     }
  277.                 }
  278.             }
  279.         }
  280.        
  281.         private class InvalidValuesCollection : IEnumerable
  282.         {
  283.             ConfigurationValues _values;
  284.            
  285.             internal InvalidValuesCollection(ConfigurationValues values)
  286.             {
  287.                 _values = values;
  288.             }
  289.            
  290.             IEnumerator IEnumerable.GetEnumerator()
  291.             {
  292.                 if (_values._containsInvalidValue) {
  293.                     for (int index = 0; index < _values.Count; index++) {
  294.                         object value = _values[index];
  295.                         if (value is InvalidPropValue) {
  296.                             yield return value;
  297.                         }
  298.                     }
  299.                 }
  300.             }
  301.         }
  302.        
  303.         /*
  304.         internal bool IsLocked(string key)
  305.         {
  306.             ConfigurationValue configurationValue = (ConfigurationValue)BaseGet(key);
  307.             if (configurationValue != null)
  308.                 return ((configurationValue.ValueFlags & ConfigurationValueFlags.Locked) != 0);
  309.             else
  310.                 return false;
  311.         }
  312.         internal bool IsReadOnly(string key)
  313.         {
  314.             ConfigurationValue configurationValue = (ConfigurationValue)BaseGet(key);
  315.             if (configurationValue != null)
  316.                 return ((configurationValue.ValueFlags & ConfigurationValueFlags.ReadOnly) != 0);
  317.             else
  318.                 return false;
  319.         }
  320.         */       
  321.        
  322.     }
  323. }

Developer Fusion