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

SSCLI
  1. //------------------------------------------------------------------------------
  2. // <copyright file="ListenerElementsCollection.cs" company="Microsoft Corporation">
  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.Configuration;
  16. using System;
  17. using System.Reflection;
  18. using System.Globalization;
  19. using System.Xml;
  20. using System.Collections.Specialized;
  21. using System.Collections;
  22. using System.Security;
  23. using System.Security.Permissions;
  25. namespace System.Diagnostics
  26. {
  27.     [ConfigurationCollection(typeof(ListenerElement))]
  28.     internal class ListenerElementsCollection : ConfigurationElementCollection
  29.     {
  30.        
  31.         public new ListenerElement this[string name]
  32.         {
  33.             get { return (ListenerElement)BaseGet(name); }
  34.         }
  35.        
  36.         public override ConfigurationElementCollectionType CollectionType {
  37.             get { return ConfigurationElementCollectionType.AddRemoveClearMap; }
  38.         }
  39.        
  40.         protected override ConfigurationElement CreateNewElement()
  41.         {
  42.             return new ListenerElement(true);
  43.         }
  44.        
  45.         protected override object GetElementKey(ConfigurationElement element)
  46.         {
  47.             return ((ListenerElement)element).Name;
  48.         }
  49.        
  50.         public TraceListenerCollection GetRuntimeObject()
  51.         {
  52.             TraceListenerCollection listeners = new TraceListenerCollection();
  53.             bool _isDemanded = false;
  54.            
  55.             foreach (ListenerElement element in this) {
  56.                
  57.                 // At some point, we need to pull out adding/removing the 'default' DefaultTraceListener
  58.                 // code from here in favor of adding/not-adding after we load the config (in TraceSource
  59.                 // and in static Trace)
  60.                
  61.                 if (!_isDemanded && !element._isAddedByDefault) {
  62.                     // Do a full damand; This will disable partially trusted code from hooking up listeners
  63.                     new SecurityPermission(SecurityPermissionFlag.UnmanagedCode).Demand();
  64.                     _isDemanded = true;
  65.                 }
  66.                
  67.                 listeners.Add(element.GetRuntimeObject());
  68.             }
  69.            
  70.             return listeners;
  71.         }
  72.        
  73.         protected override void InitializeDefault()
  74.         {
  75.             InitializeDefaultInternal();
  76.         }
  77.        
  78.         internal void InitializeDefaultInternal()
  79.         {
  80.             ListenerElement defaultListener = new ListenerElement(false);
  81.             defaultListener.Name = "Default";
  82.             defaultListener.TypeName = typeof(DefaultTraceListener).FullName;
  83.             defaultListener._isAddedByDefault = true;
  84.            
  85.             this.BaseAdd(defaultListener);
  86.         }
  87.        
  88.         protected override void BaseAdd(ConfigurationElement element)
  89.         {
  90.             ListenerElement listenerElement = element as ListenerElement;
  91.            
  92.             Debug.Assert((listenerElement != null), "adding elements other than ListenerElement to ListenerElementsCollection?");
  93.            
  94.             if (listenerElement.Name.Equals("Default") && listenerElement.TypeName.Equals(typeof(DefaultTraceListener).FullName))
  95.                 BaseAdd(listenerElement, false);
  96.             else
  97.                 BaseAdd(listenerElement, ThrowOnDuplicate);
  98.         }
  99.     }
  100.    
  101.     // This is the collection used by the sharedListener section. It is only slightly different from ListenerElementsCollection.
  102.     // The differences are that it does not allow remove and clear, and that the ListenerElements it creates do not allow
  103.     // references.
  104.     [ConfigurationCollection(typeof(ListenerElement), AddItemName = "add", CollectionType = ConfigurationElementCollectionType.BasicMap)]
  105.     internal class SharedListenerElementsCollection : ListenerElementsCollection
  106.     {
  107.        
  108.         public override ConfigurationElementCollectionType CollectionType {
  109.             get { return ConfigurationElementCollectionType.BasicMap; }
  110.         }
  111.        
  112.         protected override ConfigurationElement CreateNewElement()
  113.         {
  114.             return new ListenerElement(false);
  115.         }
  116.        
  117.         protected override string ElementName {
  118.             get { return "add"; }
  119.         }
  120.     }
  121.    
  122.     internal class ListenerElement : TypedElement
  123.     {
  124.         private static readonly ConfigurationProperty _propFilter = new ConfigurationProperty("filter", typeof(FilterElement), null, ConfigurationPropertyOptions.None);
  125.         private static readonly ConfigurationProperty _propName = new ConfigurationProperty("name", typeof(string), null, ConfigurationPropertyOptions.IsRequired | ConfigurationPropertyOptions.IsKey);
  126.         private static readonly ConfigurationProperty _propOutputOpts = new ConfigurationProperty("traceOutputOptions", typeof(TraceOptions), TraceOptions.None, ConfigurationPropertyOptions.None);
  127.        
  128.         private ConfigurationProperty _propListenerTypeName;
  129.         private bool _allowReferences;
  130.         private Hashtable _attributes;
  131.         internal bool _isAddedByDefault;
  132.        
  133.         static ListenerElement()
  134.         {
  135.         }
  136.        
  137.         public ListenerElement(bool allowReferences) : base(typeof(TraceListener))
  138.         {
  139.             _allowReferences = allowReferences;
  140.            
  141.             ConfigurationPropertyOptions flags = ConfigurationPropertyOptions.None;
  142.             if (!_allowReferences)
  143.                 flags |= ConfigurationPropertyOptions.IsRequired;
  144.            
  145.             _propListenerTypeName = new ConfigurationProperty("type", typeof(string), null, flags);
  146.            
  147.             _properties.Remove("type");
  148.             _properties.Add(_propListenerTypeName);
  149.             _properties.Add(_propFilter);
  150.             _properties.Add(_propName);
  151.             _properties.Add(_propOutputOpts);
  152.         }
  153.        
  154.         public Hashtable Attributes {
  155.             get {
  156.                 if (_attributes == null)
  157.                     _attributes = new Hashtable(StringComparer.OrdinalIgnoreCase);
  158.                 return _attributes;
  159.             }
  160.         }
  161.        
  162.         [ConfigurationProperty("filter")]
  163.         public FilterElement Filter {
  164.             get { return (FilterElement)this[_propFilter]; }
  165.         }
  166.        
  167.         [ConfigurationProperty("name", IsRequired = true, IsKey = true)]
  168.         public string Name {
  169.             get { return (string)this[_propName]; }
  170.             set { this[_propName] = value; }
  171.         }
  172.        
  173.         [ConfigurationProperty("traceOutputOptions", DefaultValue = (TraceOptions)TraceOptions.None)]
  174.         public TraceOptions TraceOutputOptions {
  175.             get { return (TraceOptions)this[_propOutputOpts]; }
  176.             // This is useful when the OM becomes public. In the meantime, this can be utilized via reflection
  177.             set { this[_propOutputOpts] = value; }
  178.         }
  179.        
  180.        
  181.         [ConfigurationProperty("type")]
  182.         public override string TypeName {
  183.             get { return (string)this[_propListenerTypeName]; }
  184.             set { this[_propListenerTypeName] = value; }
  185.         }
  186.        
  187.         public override bool Equals(object compareTo)
  188.         {
  189.             if (this.Name.Equals("Default") && this.TypeName.Equals(typeof(DefaultTraceListener).FullName)) {
  190.                 // This is a workaround to treat all DefaultTraceListener named 'Default' the same.
  191.                 // This is needed for the Config.Save to work properly as otherwise config base layers
  192.                 // above us would run into duplicate 'Default' listener element and perceive it as
  193.                 // error.
  194.                 ListenerElement compareToElem = compareTo as ListenerElement;
  195.                 return (compareToElem != null) && compareToElem.Name.Equals("Default") && compareToElem.TypeName.Equals(typeof(DefaultTraceListener).FullName);
  196.             }
  197.             else
  198.                 return base.Equals(compareTo);
  199.         }
  200.        
  201.         public override int GetHashCode()
  202.         {
  203.             return base.GetHashCode();
  204.         }
  205.        
  206.         public TraceListener GetRuntimeObject()
  207.         {
  208.             if (_runtimeObject != null)
  209.                 return (TraceListener)_runtimeObject;
  210.            
  211.             try {
  212.                 string className = TypeName;
  213.                 if (String.IsNullOrEmpty(className)) {
  214.                     // Look it up in SharedListeners
  215.                     Debug.Assert(_allowReferences, "_allowReferences must be true if type name is null");
  216.                    
  217.                     if (_attributes != null || ElementInformation.Properties[_propFilter.Name].ValueOrigin == PropertyValueOrigin.SetHere || TraceOutputOptions != TraceOptions.None || !String.IsNullOrEmpty(InitData))
  218.                         throw new ConfigurationErrorsException(SR.GetString(SR.Reference_listener_cant_have_properties, Name));
  219.                    
  220.                     if (DiagnosticsConfiguration.SharedListeners == null)
  221.                         throw new ConfigurationErrorsException(SR.GetString(SR.Reference_to_nonexistent_listener, Name));
  222.                    
  223.                     ListenerElement sharedListener = DiagnosticsConfiguration.SharedListeners[Name];
  224.                     if (sharedListener == null)
  225.                         throw new ConfigurationErrorsException(SR.GetString(SR.Reference_to_nonexistent_listener, Name));
  226.                     else {
  227.                         _runtimeObject = sharedListener.GetRuntimeObject();
  228.                         return (TraceListener)_runtimeObject;
  229.                     }
  230.                 }
  231.                 else {
  232.                     // create a new one
  233.                     TraceListener newListener = (TraceListener)BaseGetRuntimeObject();
  234.                     newListener.initializeData = InitData;
  235.                     newListener.Name = Name;
  236.                     newListener.SetAttributes(Attributes);
  237.                     newListener.TraceOutputOptions = TraceOutputOptions;
  238.                    
  239.                     if ((Filter != null) && (Filter.TypeName != null) && (Filter.TypeName.Length != 0))
  240.                         newListener.Filter = Filter.GetRuntimeObject();
  241.                    
  242.                     _runtimeObject = newListener;
  243.                     return newListener;
  244.                 }
  245.             }
  246.             catch (ArgumentException e) {
  247.                 throw new ConfigurationErrorsException(SR.GetString(SR.Could_not_create_listener, Name), e);
  248.             }
  249.         }
  250.        
  251.         protected override bool OnDeserializeUnrecognizedAttribute(string name, string value)
  252.         {
  253.             ConfigurationProperty _propDynamic = new ConfigurationProperty(name, typeof(string), value);
  254.             _properties.Add(_propDynamic);
  255.             base[_propDynamic] = value;
  256.             // Add them to the property bag
  257.             Attributes.Add(name, value);
  258.             return true;
  259.         }
  260.        
  261.         internal void ResetProperties()
  262.         {
  263.             // blow away any UnrecognizedAttributes that we have deserialized earlier
  264.             if (_attributes != null) {
  265.                 _attributes.Clear();
  266.                 _properties.Clear();
  267.                 _properties.Add(_propListenerTypeName);
  268.                 _properties.Add(_propFilter);
  269.                 _properties.Add(_propName);
  270.                 _properties.Add(_propOutputOpts);
  271.             }
  272.         }
  273.        
  274.         internal TraceListener RefreshRuntimeObject(TraceListener listener)
  275.         {
  276.             _runtimeObject = null;
  277.             try {
  278.                 string className = TypeName;
  279.                 if (String.IsNullOrEmpty(className)) {
  280.                     // Look it up in SharedListeners and ask the sharedListener to refresh.
  281.                     Debug.Assert(_allowReferences, "_allowReferences must be true if type name is null");
  282.                    
  283.                     if (_attributes != null || ElementInformation.Properties[_propFilter.Name].ValueOrigin == PropertyValueOrigin.SetHere || TraceOutputOptions != TraceOptions.None || !String.IsNullOrEmpty(InitData))
  284.                         throw new ConfigurationErrorsException(SR.GetString(SR.Reference_listener_cant_have_properties, Name));
  285.                    
  286.                     if (DiagnosticsConfiguration.SharedListeners == null)
  287.                         throw new ConfigurationErrorsException(SR.GetString(SR.Reference_to_nonexistent_listener, Name));
  288.                    
  289.                     ListenerElement sharedListener = DiagnosticsConfiguration.SharedListeners[Name];
  290.                     if (sharedListener == null)
  291.                         throw new ConfigurationErrorsException(SR.GetString(SR.Reference_to_nonexistent_listener, Name));
  292.                     else {
  293.                         _runtimeObject = sharedListener.RefreshRuntimeObject(listener);
  294.                         return (TraceListener)_runtimeObject;
  295.                     }
  296.                 }
  297.                 else {
  298.                     // We're the element with the type and initializeData info. First see if those two are the same as they were.
  299.                     // If not, create a whole new object, otherwise, just update the other properties.
  300.                     if (Type.GetType(className) != listener.GetType() || InitData != listener.initializeData) {
  301.                         // type or initdata changed
  302.                         return GetRuntimeObject();
  303.                     }
  304.                     else {
  305.                         listener.SetAttributes(Attributes);
  306.                         listener.TraceOutputOptions = TraceOutputOptions;
  307.                        
  308.                         if (ElementInformation.Properties[_propFilter.Name].ValueOrigin == PropertyValueOrigin.SetHere)
  309.                             listener.Filter = Filter.RefreshRuntimeObject(listener.Filter);
  310.                         else
  311.                             listener.Filter = null;
  312.                        
  313.                         _runtimeObject = listener;
  314.                         return listener;
  315.                     }
  316.                 }
  317.             }
  318.             catch (ArgumentException e) {
  319.                 throw new ConfigurationErrorsException(SR.GetString(SR.Could_not_create_listener, Name), e);
  320.             }
  321.            
  322.         }
  323.        
  324.     }
  325. }

Developer Fusion