We need you! We're working hard on the next version of Developer Fusion - Let us know what you think we should be up to!

The Labs \ Source Viewer \ SSCLI \ System.Diagnostics \ Switch

SSCLI
  1. //------------------------------------------------------------------------------
  2. // <copyright file="Switch.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. //------------------------------------------------------------------------------
  16. /*
  17. */
  19. namespace System.Diagnostics
  20. {
  21.     using System;
  22.     using System.Security;
  23.     using System.Security.Permissions;
  24.     using System.Threading;
  25.     using System.Runtime.InteropServices;
  26.     using Microsoft.Win32;
  27.     using System.Collections;
  28.     using System.Collections.Generic;
  29.     using System.Collections.Specialized;
  30.     using System.Globalization;
  31.     using System.Configuration;
  32.     using System.Xml.Serialization;
  33.    
  34.     /// <devdoc>
  35.     /// <para>Provides an <see langword='abstract '/>base class to
  36.     /// create new debugging and tracing switches.</para>
  37.     /// </devdoc>
  38.     public abstract class Switch
  39.     {
  40.         private SwitchElementsCollection switchSettings;
  41.         private string description;
  42.         private string displayName;
  43.         private int switchSetting = 0;
  44.         private bool initialized = false;
  45.         private bool initializing = false;
  46.         private string switchValueString = String.Empty;
  47.         private StringDictionary attributes;
  48.         private string defaultValue;
  49.        
  50.         private static List<WeakReference> switches = new List<WeakReference>();
  51.        
  52.         /// <devdoc>
  53.         /// <para>Initializes a new instance of the <see cref='System.Diagnostics.Switch'/>
  54.         /// class.</para>
  55.         /// </devdoc>
  56.         protected Switch(string displayName, string description) : this(displayName, description, "0")
  57.         {
  58.         }
  59.        
  60.         protected Switch(string displayName, string description, string defaultSwitchValue)
  61.         {
  62.             // displayName is used as a hashtable key, so it can never
  63.             // be null.
  64.             if (displayName == null)
  65.                 displayName = string.Empty;
  66.            
  67.             this.displayName = displayName;
  68.             this.description = description;
  69.            
  70.             lock (switches) {
  71.                 switches.Add(new WeakReference(this));
  72.             }
  73.            
  74.             defaultValue = defaultSwitchValue;
  75.         }
  76.        
  77.         [XmlIgnore()]
  78.         public StringDictionary Attributes {
  79.             get {
  80.                 Initialize();
  81.                 if (attributes == null)
  82.                     attributes = new StringDictionary();
  83.                 return attributes;
  84.             }
  85.         }
  86.        
  87.         /// <devdoc>
  88.         /// <para>Gets a name used to identify the switch.</para>
  89.         /// </devdoc>
  90.         public string DisplayName {
  91.             get { return displayName; }
  92.         }
  93.        
  94.         /// <devdoc>
  95.         /// <para>Gets a description of the switch.</para>
  96.         /// </devdoc>
  97.         public string Description {
  98.             get { return (description == null) ? string.Empty : description; }
  99.         }
  100.        
  101.         /// <devdoc>
  102.         /// <para>
  103.         /// Indicates the current setting for this switch.
  104.         /// </para>
  105.         /// </devdoc>
  106.         protected int SwitchSetting {
  107.             get {
  108.                 if (!initialized) {
  109.                     if (!InitializeWithStatus())
  110.                         return 0;
  111.                     OnSwitchSettingChanged();
  112.                 }
  113.                 return switchSetting;
  114.             }
  115.             set {
  116.                 initialized = true;
  117.                 if (switchSetting != value) {
  118.                     switchSetting = value;
  119.                     OnSwitchSettingChanged();
  120.                 }
  121.             }
  122.         }
  123.        
  124.         protected string Value {
  125.             get {
  126.                 Initialize();
  127.                 return switchValueString;
  128.             }
  129.             set {
  130.                 Initialize();
  131.                 switchValueString = value;
  132.                 try {
  133.                     OnValueChanged();
  134.                 }
  135.                 catch (ArgumentException e) {
  136.                     throw new ConfigurationErrorsException(SR.GetString(SR.BadConfigSwitchValue, DisplayName), e);
  137.                 }
  138.                 catch (FormatException e) {
  139.                     throw new ConfigurationErrorsException(SR.GetString(SR.BadConfigSwitchValue, DisplayName), e);
  140.                 }
  141.                 catch (OverflowException e) {
  142.                     throw new ConfigurationErrorsException(SR.GetString(SR.BadConfigSwitchValue, DisplayName), e);
  143.                 }
  144.             }
  145.         }
  146.        
  147.         private void Initialize()
  148.         {
  149.             InitializeWithStatus();
  150.         }
  151.        
  152.         private bool InitializeWithStatus()
  153.         {
  154.             if (!initialized) {
  155.                
  156.                 if (initializing)
  157.                     return false;
  158.                
  159.                 initializing = true;
  160.                
  161.                 if (switchSettings == null) {
  162.                     if (!InitializeConfigSettings())
  163.                         return false;
  164.                 }
  165.                
  166.                 if (switchSettings != null) {
  167.                     SwitchElement mySettings = switchSettings[displayName];
  168.                     if (mySettings != null) {
  169.                         string value = mySettings.Value;
  170.                         if (value != null) {
  171.                             this.Value = value;
  172.                         }
  173.                         else
  174.                             this.Value = defaultValue;
  175.                        
  176.                         try {
  177.                             TraceUtils.VerifyAttributes(mySettings.Attributes, GetSupportedAttributes(), this);
  178.                         }
  179.                         catch (ConfigurationException) {
  180.                             // if VerifyAttributes throws, clean up a little bit so we're not in a bad state.
  181.                             initialized = false;
  182.                             initializing = false;
  183.                             throw;
  184.                         }
  185.                        
  186.                         attributes = new StringDictionary();
  187.                         attributes.contents = mySettings.Attributes;
  188.                     }
  189.                     else {
  190.                         // We don't use the property here because we don't want to catch exceptions
  191.                         // and rethrow them as ConfigurationException. In this case there's no config.
  192.                         switchValueString = defaultValue;
  193.                         OnValueChanged();
  194.                     }
  195.                 }
  196.                 else {
  197.                     // We don't use the property here because we don't want to catch exceptions
  198.                     // and rethrow them as ConfigurationException. In this case there's no config.
  199.                     switchValueString = defaultValue;
  200.                     OnValueChanged();
  201.                 }
  202.                
  203.                 initialized = true;
  204.                 initializing = false;
  205.             }
  206.            
  207.             return true;
  208.         }
  209.        
  210.         private bool InitializeConfigSettings()
  211.         {
  212.             if (switchSettings != null)
  213.                 return true;
  214.            
  215.             if (!DiagnosticsConfiguration.CanInitialize())
  216.                 return false;
  217.            
  218.             // This hashtable is case-insensitive.
  219.             switchSettings = DiagnosticsConfiguration.SwitchSettings;
  220.             return true;
  221.         }
  222.        
  223.         protected internal virtual string[] GetSupportedAttributes()
  224.         {
  225.             return null;
  226.         }
  227.        
  228.         /// <devdoc>
  229.         /// This method is invoked when a switch setting has been changed. It will
  230.         /// be invoked the first time a switch reads its value from the registry
  231.         /// or environment, and then it will be invoked each time the switch's
  232.         /// value is changed.
  233.         /// </devdoc>
  234.         protected virtual void OnSwitchSettingChanged()
  235.         {
  236.         }
  237.        
  238.         protected virtual void OnValueChanged()
  239.         {
  240.             SwitchSetting = Int32.Parse(Value, CultureInfo.InvariantCulture);
  241.         }
  242.        
  243.         static internal void RefreshAll()
  244.         {
  245.            
  246.             lock (switches) {
  247.                 for (int i = 0; i < switches.Count; i++) {
  248.                     Switch swtch = ((Switch)switches[i].Target);
  249.                     if (swtch != null) {
  250.                         swtch.Refresh();
  251.                     }
  252.                 }
  253.             }
  254.         }
  255.        
  256.         internal void Refresh()
  257.         {
  258.             initialized = false;
  259.             switchSettings = null;
  260.             Initialize();
  261.         }
  262.        
  263.     }
  264. }

Developer Fusion