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 \ DiagnosticsConfiguration

SSCLI
  1. //------------------------------------------------------------------------------
  2. // <copyright file="DiagnosticsConfiguration.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. namespace System.Diagnostics
  17. {
  18.     using System;
  19.     using System.Reflection;
  20.     using System.Collections;
  21.     using System.Configuration;
  22.     using System.Threading;
  23.     using System.Runtime.Versioning;
  24.    
  25.     internal enum InitState
  26.     {
  27.         NotInitialized,
  28.         Initializing,
  29.         Initialized
  30.     }
  31.    
  32.     static internal class DiagnosticsConfiguration
  33.     {
  34.         private static SystemDiagnosticsSection configSection;
  35.         private static InitState initState = InitState.NotInitialized;
  36.        
  37.         // setting for Switch.switchSetting
  38.         static internal SwitchElementsCollection SwitchSettings {
  39.             get {
  40.                 Initialize();
  41.                 SystemDiagnosticsSection configSectionSav = configSection;
  42.                 if (configSectionSav != null)
  43.                     return configSectionSav.Switches;
  44.                 else
  45.                     return null;
  46.             }
  47.         }
  48.        
  49.         // setting for DefaultTraceListener.AssertUIEnabled
  50.         static internal bool AssertUIEnabled {
  51.             get {
  52.                 Initialize();
  53.                 SystemDiagnosticsSection configSectionSav = configSection;
  54.                 if (configSectionSav != null && configSectionSav.Assert != null)
  55.                     return configSectionSav.Assert.AssertUIEnabled;
  56.                 else
  57.                     return true;
  58.                 // the default
  59.             }
  60.         }
  61.        
  62.         static internal string ConfigFilePath {
  63.             get {
  64.                 Initialize();
  65.                 SystemDiagnosticsSection configSectionSav = configSection;
  66.                 if (configSectionSav != null)
  67.                     return configSectionSav.ElementInformation.Source;
  68.                 else
  69.                     return string.Empty;
  70.                 // the default
  71.             }
  72.         }
  73.        
  74.         // setting for DefaultTraceListener.LogFileName
  75.         static internal string LogFileName {
  76.             [ResourceExposure(ResourceScope.Machine)]
  77.             [ResourceConsumption(ResourceScope.Machine)]
  78.             get {
  79.                 Initialize();
  80.                 SystemDiagnosticsSection configSectionSav = configSection;
  81.                 if (configSectionSav != null && configSectionSav.Assert != null)
  82.                     return configSectionSav.Assert.LogFileName;
  83.                 else
  84.                     return string.Empty;
  85.                 // the default
  86.             }
  87.         }
  88.        
  89.         // setting for TraceInternal.AutoFlush
  90.         static internal bool AutoFlush {
  91.             get {
  92.                 Initialize();
  93.                 SystemDiagnosticsSection configSectionSav = configSection;
  94.                 if (configSectionSav != null && configSectionSav.Trace != null)
  95.                     return configSectionSav.Trace.AutoFlush;
  96.                 else
  97.                     return false;
  98.                 // the default
  99.             }
  100.         }
  101.        
  102.         // setting for TraceInternal.UseGlobalLock
  103.         static internal bool UseGlobalLock {
  104.             get {
  105.                 Initialize();
  106.                 SystemDiagnosticsSection configSectionSav = configSection;
  107.                 if (configSectionSav != null && configSectionSav.Trace != null)
  108.                     return configSectionSav.Trace.UseGlobalLock;
  109.                 else
  110.                     return true;
  111.                 // the default
  112.             }
  113.         }
  114.        
  115.         // setting for TraceInternal.IndentSize
  116.         static internal int IndentSize {
  117.             get {
  118.                 Initialize();
  119.                 SystemDiagnosticsSection configSectionSav = configSection;
  120.                 if (configSectionSav != null && configSectionSav.Trace != null)
  121.                     return configSectionSav.Trace.IndentSize;
  122.                 else
  123.                     return 4;
  124.                 // the default
  125.             }
  126.         }
  127.        
  128.        
  129.         static internal ListenerElementsCollection SharedListeners {
  130.             get {
  131.                 Initialize();
  132.                 SystemDiagnosticsSection configSectionSav = configSection;
  133.                 if (configSectionSav != null)
  134.                     return configSectionSav.SharedListeners;
  135.                 else
  136.                     return null;
  137.             }
  138.         }
  139.        
  140.         static internal SourceElementsCollection Sources {
  141.             get {
  142.                 Initialize();
  143.                 SystemDiagnosticsSection configSectionSav = configSection;
  144.                 if (configSectionSav != null && configSectionSav.Sources != null)
  145.                     return configSectionSav.Sources;
  146.                 else
  147.                     return null;
  148.             }
  149.         }
  150.        
  151.         static internal SystemDiagnosticsSection SystemDiagnosticsSection {
  152.             get {
  153.                 Initialize();
  154.                 return configSection;
  155.             }
  156.         }
  157.        
  158.         private static SystemDiagnosticsSection GetConfigSection()
  159.         {
  160.             SystemDiagnosticsSection configSection = (SystemDiagnosticsSection)PrivilegedConfigurationManager.GetSection("system.diagnostics");
  161.             return configSection;
  162.         }
  163.        
  164.         static internal bool IsInitializing()
  165.         {
  166.             return initState == InitState.Initializing;
  167.         }
  168.        
  169.         static internal bool IsInitialized()
  170.         {
  171.             return initState == InitState.Initialized;
  172.         }
  173.        
  174.        
  175.         static internal bool CanInitialize()
  176.         {
  177.             return (initState != InitState.Initializing) && !ConfigurationManagerInternalFactory.Instance.SetConfigurationSystemInProgress;
  178.         }
  179.        
  180.         static internal void Initialize()
  181.         {
  182.             // Initialize() is also called by other components outside of Trace (such as PerformanceCounter)
  183.             // as a result using one lock for this critical section and another for Trace API critical sections
  184.             // (such as Trace.WriteLine) could potentially lead to deadlock between 2 threads that are
  185.             // executing these critical sections (and consequently obtaining the 2 locks) in the reverse order.
  186.             // Using the same lock for DiagnosticsConfiguration as well as TraceInternal avoids this issue.
  187.             // Sequential locks on TraceInternal.critSec by the same thread is a non issue for this critical section.
  188.             lock (TraceInternal.critSec) {
  189.                
  190.                 // because some of the code used to load config also uses diagnostics
  191.                 // we can't block them while we initialize from config. Therefore we just
  192.                 // return immediately and they just use the default values.
  193.                 if (initState != InitState.NotInitialized || ConfigurationManagerInternalFactory.Instance.SetConfigurationSystemInProgress) {
  194.                    
  195.                     return;
  196.                 }
  197.                
  198.                 initState = InitState.Initializing;
  199.                 // used for preventing recursion
  200.                 try {
  201.                     configSection = GetConfigSection();
  202.                 }
  203.                 finally {
  204.                     initState = InitState.Initialized;
  205.                 }
  206.             }
  207.         }
  208.        
  209.         static internal void Refresh()
  210.         {
  211.             ConfigurationManager.RefreshSection("system.diagnostics");
  212.            
  213.             // There might still be some persistant state left behind for
  214.             // ConfigPropertyCollection (for ex, swtichelements), probably for perf.
  215.             // We need to explicitly cleanup any unrecognized attributes that we
  216.             // have added during last deserialization, so that they are re-added
  217.             // during the next Config.GetSection properly and we get a chance to
  218.             // populate the Attributes collection for re-deserialization.
  219.             // Another alternative could be to expose the properties collection
  220.             // directly as Attributes collection (currently we keep a local
  221.             // hashtable which we explicitly need to keep in sycn and hence the
  222.             // cleanup logic below) but the down side of that would be we need to
  223.             // explicitly compute what is recognized Vs unrecognized from that
  224.             // collection when we expose the unrecognized Attributes publically
  225.             SystemDiagnosticsSection configSectionSav = configSection;
  226.             if (configSectionSav != null) {
  227.                
  228.                 if (configSectionSav.Switches != null) {
  229.                     foreach (SwitchElement swelem in configSectionSav.Switches)
  230.                         swelem.ResetProperties();
  231.                 }
  232.                
  233.                 if (configSectionSav.SharedListeners != null) {
  234.                     foreach (ListenerElement lnelem in configSectionSav.SharedListeners)
  235.                         lnelem.ResetProperties();
  236.                 }
  237.                
  238.                 if (configSectionSav.Sources != null) {
  239.                     foreach (SourceElement srelem in configSectionSav.Sources)
  240.                         srelem.ResetProperties();
  241.                 }
  242.             }
  243.            
  244.             configSection = null;
  245.            
  246.             initState = InitState.NotInitialized;
  247.             Initialize();
  248.         }
  249.     }
  250. }

Developer Fusion