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

SSCLI
  1. //------------------------------------------------------------------------------
  2. // <copyright file="DiagnosticsConfigurationHandler.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. #if !LIB
  17. #define TRACE
  18. #define DEBUG
  19. namespace System.Diagnostics
  20. {
  21.    
  22.     using System;
  23.     using System.Collections;
  24.     using System.Diagnostics;
  25.     using System.Xml;
  26.     using System.Configuration;
  27.     using System.Reflection;
  28.     using System.Globalization;
  29.    
  30.     /// <devdoc>
  31.     /// The configuration section handler for the diagnostics section of the configuration
  32.     /// file. The section handler participates in the resolution of configuration settings
  33.     /// between the &lt;diagnostics&gt; and &lt;/diagnostics&gt;portion of the .config file.
  34.     /// </devdoc>
  35.     /// <internalonly/>
  36.     [Obsolete("This class has been deprecated. http://go.microsoft.com/fwlink/?linkid=14202")]
  37.     public class DiagnosticsConfigurationHandler : IConfigurationSectionHandler
  38.     {
  39.        
  40.         /// <devdoc>
  41.         /// <para>Parses the configuration settings between the
  42.         /// &lt;diagnostics&gt; and &lt;/diagnostics&gt; portion of the .config file to populate
  43.         /// the values of 'WebServicesConfiguration' object and returning it.
  44.         /// </para>
  45.         /// </devdoc>
  46.         /// <internalonly/>
  47.         public virtual object Create(object parent, object configContext, XmlNode section)
  48.         {
  49.             bool foundSwitches = false;
  50.             bool foundAssert = false;
  51.             bool foundTrace = false;
  52.             bool foundCounters = false;
  53.            
  54.             HandlerBase.CheckForUnrecognizedAttributes(section);
  55.            
  56.             // Since the tracing and switch code lives in System.Dll and config is in System.Configuration.dll
  57.             // the settings just go into a hashtable to communicate to the values to the diagnostics code in System.dll
  58.             Hashtable parentConfig = (Hashtable)parent;
  59.             Hashtable config;
  60.             if (parentConfig == null)
  61.                 config = new Hashtable();
  62.             else
  63.                 config = (Hashtable)parentConfig.Clone();
  64.            
  65.             foreach (XmlNode child in section.ChildNodes) {
  66.                 if (HandlerBase.IsIgnorableAlsoCheckForNonElement(child))
  67.                     continue;
  68.                
  69.                 switch (child.Name) {
  70.                     case "switches":
  71.                         if (foundSwitches)
  72.                             throw new ConfigurationErrorsException(SR.GetString(SR.ConfigSectionsUnique, "switches"));
  74.                         foundSwitches = true;
  75.                        
  76.                         HandleSwitches(config, child, configContext);
  77.                         break;
  78.                     case "assert":
  79.                         if (foundAssert)
  80.                             throw new ConfigurationErrorsException(SR.GetString(SR.ConfigSectionsUnique, "assert"));
  82.                         foundAssert = true;
  83.                        
  84.                         HandleAssert(config, child, configContext);
  85.                         break;
  86.                     case "trace":
  87.                         if (foundTrace)
  88.                             throw new ConfigurationErrorsException(SR.GetString(SR.ConfigSectionsUnique, "trace"));
  90.                         foundTrace = true;
  91.                        
  92.                         HandleTrace(config, child, configContext);
  93.                         break;
  94.                     case "performanceCounters":
  95.                         if (foundCounters)
  96.                             throw new ConfigurationErrorsException(SR.GetString(SR.ConfigSectionsUnique, "performanceCounters"));
  98.                         foundCounters = true;
  99.                        
  100.                         HandleCounters((Hashtable)parent, config, child, configContext);
  101.                         break;
  102.                     default:
  103.                         HandlerBase.ThrowUnrecognizedElement(child);
  104.                         break;
  105.                 }
  106.                 // switch(child.Name)
  107.                 HandlerBase.CheckForUnrecognizedAttributes(child);
  108.             }
  109.             return config;
  110.         }
  111.        
  112.         private static void HandleSwitches(Hashtable config, XmlNode switchesNode, object context)
  113.         {
  114.             Hashtable switches = (Hashtable)new SwitchesDictionarySectionHandler().Create(config["switches"], context, switchesNode);
  115.             IDictionaryEnumerator en = switches.GetEnumerator();
  116.             while (en.MoveNext()) {
  117.                 try {
  118.                     Int32.Parse((string)en.Value, CultureInfo.InvariantCulture);
  119.                 }
  120.                 catch {
  121.                     throw new ConfigurationErrorsException(SR.GetString(SR.Value_must_be_numeric, en.Key));
  122.                 }
  123.             }
  124.            
  125.             config["switches"] = switches;
  126.         }
  127.        
  128.         private static void HandleAssert(Hashtable config, XmlNode assertNode, object context)
  129.         {
  130.             bool assertuienabled = false;
  131.             if (HandlerBase.GetAndRemoveBooleanAttribute(assertNode, "assertuienabled", ref assertuienabled) != null)
  132.                 config["assertuienabled"] = assertuienabled;
  133.            
  134.             string logfilename = null;
  135.             if (HandlerBase.GetAndRemoveStringAttribute(assertNode, "logfilename", ref logfilename) != null)
  136.                 config["logfilename"] = logfilename;
  137.            
  138.             HandlerBase.CheckForChildNodes(assertNode);
  139.         }
  140.        
  141.         private static void HandleCounters(Hashtable parent, Hashtable config, XmlNode countersNode, object context)
  142.         {
  143.             int filemappingsize = 0;
  144.             if (HandlerBase.GetAndRemoveIntegerAttribute(countersNode, "filemappingsize", ref filemappingsize) != null) {
  145.                 //Should only be handled at machine config level
  146.                 if (parent == null)
  147.                     config["filemappingsize"] = filemappingsize;
  148.             }
  149.            
  150.             HandlerBase.CheckForChildNodes(countersNode);
  151.         }
  152.        
  153.         private static void HandleTrace(Hashtable config, XmlNode traceNode, object context)
  154.         {
  155.             bool foundListeners = false;
  156.             bool autoflush = false;
  157.             if (HandlerBase.GetAndRemoveBooleanAttribute(traceNode, "autoflush", ref autoflush) != null)
  158.                 config["autoflush"] = autoflush;
  159.            
  160.             int indentsize = 0;
  161.             if (HandlerBase.GetAndRemoveIntegerAttribute(traceNode, "indentsize", ref indentsize) != null)
  162.                 config["indentsize"] = indentsize;
  163.            
  164.             foreach (XmlNode traceChild in traceNode.ChildNodes) {
  165.                 if (HandlerBase.IsIgnorableAlsoCheckForNonElement(traceChild))
  166.                     continue;
  167.                
  168.                 if (traceChild.Name == "listeners") {
  169.                     if (foundListeners)
  170.                         throw new ConfigurationErrorsException(SR.GetString(SR.ConfigSectionsUnique, "listeners"));
  171.                     foundListeners = true;
  172.                    
  173.                     HandleListeners(config, traceChild, context);
  174.                 }
  175.                 else {
  176.                     HandlerBase.ThrowUnrecognizedElement(traceChild);
  177.                 }
  178.             }
  179.         }
  180.        
  181.         private static void HandleListeners(Hashtable config, XmlNode listenersNode, object context)
  182.         {
  183.             HandlerBase.CheckForUnrecognizedAttributes(listenersNode);
  184.             foreach (XmlNode listenersChild in listenersNode.ChildNodes) {
  185.                 if (HandlerBase.IsIgnorableAlsoCheckForNonElement(listenersChild))
  186.                     continue;
  187.                
  188.                 string name = null;
  189.                 string className = null;
  190.                 string initializeData = null;
  191.                 string op = listenersChild.Name;
  192.                
  193.                 switch (op) {
  194.                     case "add":
  195.                     case "remove":
  196.                     case "clear":
  197.                         break;
  198.                     default:
  199.                         HandlerBase.ThrowUnrecognizedElement(listenersChild);
  200.                         break;
  201.                 }
  202.                
  203.                 HandlerBase.GetAndRemoveStringAttribute(listenersChild, "name", ref name);
  204.                 HandlerBase.GetAndRemoveStringAttribute(listenersChild, "type", ref className);
  205.                 HandlerBase.GetAndRemoveStringAttribute(listenersChild, "initializeData", ref initializeData);
  206.                 HandlerBase.CheckForUnrecognizedAttributes(listenersChild);
  207.                 HandlerBase.CheckForChildNodes(listenersChild);
  208.                
  209.                 TraceListener newListener = null;
  210.                 if (className != null) {
  211.                     Type t = Type.GetType(className);
  212.                    
  213.                     if (t == null)
  214.                         throw new ConfigurationErrorsException(SR.GetString(SR.Could_not_find_type, className));
  215.                    
  216.                     if (!typeof(TraceListener).IsAssignableFrom(t))
  217.                         throw new ConfigurationErrorsException(SR.GetString(SR.Type_isnt_tracelistener, className));
  218.                    
  219.                     // create a listener with parameterless constructor
  220.                     if (initializeData == null) {
  221.                         ConstructorInfo ctorInfo = t.GetConstructor(new Type[] {});
  222.                         if (ctorInfo == null)
  223.                             throw new ConfigurationErrorsException(SR.GetString(SR.Could_not_get_constructor, className));
  224.                         newListener = (TraceListener)(ctorInfo.Invoke(new object[] {}));
  225.                     }
  226.                     // create a listener with a one-string constructor
  227.                     else {
  228.                         ConstructorInfo ctorInfo = t.GetConstructor(new Type[] {typeof(string)});
  229.                         if (ctorInfo == null)
  230.                             throw new ConfigurationErrorsException(SR.GetString(SR.Could_not_get_constructor, className));
  231.                         newListener = (TraceListener)(ctorInfo.Invoke(new object[] {initializeData}));
  232.                     }
  233.                     if (name != null) {
  234.                         newListener.Name = name;
  235.                     }
  236.                 }
  237.                
  238.                 // we already verified above that we only have "add", "remove", or "clear", so we can
  239.                 // switch on the first char here for perf.
  240.                 switch (op[0]) {
  241.                     case 'a':
  242.                         if (newListener == null)
  243.                             throw new ConfigurationErrorsException(SR.GetString(SR.Could_not_create_listener, name));
  245.                        
  246.                         Trace.Listeners.Add(newListener);
  247.                        
  248.                         break;
  249.                     case 'r':
  250.                         if (newListener == null) {
  251.                             // no type specified, we'll have to delete by name
  252.                            
  253.                             // if no name is specified we can't do anything
  254.                             if (name == null)
  255.                                 throw new ConfigurationErrorsException(SR.GetString(SR.Cannot_remove_with_null));
  256.                            
  257.                             Trace.Listeners.Remove(name);
  258.                         }
  259.                         else {
  260.                             // remove by listener
  261.                             Trace.Listeners.Remove(newListener);
  262.                         }
  264.                         break;
  265.                     case 'c':
  266.                         Trace.Listeners.Clear();
  267.                         break;
  268.                     default:
  269.                         HandlerBase.ThrowUnrecognizedElement(listenersChild);
  270.                         break;
  271.                 }
  272.             }
  273.         }
  274.     }
  275.    
  276.     internal class SwitchesDictionarySectionHandler : DictionarySectionHandler
  277.     {
  278.         protected override string KeyAttributeName {
  279.             get { return "name"; }
  280.         }
  281.        
  282.         internal override bool ValueRequired {
  283.             get { return true; }
  284.         }
  285.        
  286.     }
  287. }
  289. #endif

Developer Fusion