|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Collections;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Configuration;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Xml;
namespace System.Diagnostics
{
[ConfigurationCollection(typeof(ListenerElement))]
internal class ListenerElementsCollection : ConfigurationElementCollection
{
public new ListenerElement this[string name] => (ListenerElement)BaseGet(name);
public override ConfigurationElementCollectionType CollectionType => ConfigurationElementCollectionType.AddRemoveClearMap;
protected override ConfigurationElement CreateNewElement() => new ListenerElement(true);
protected override object GetElementKey(ConfigurationElement element) => ((ListenerElement)element).Name;
public IEnumerable<TraceListener> GetRuntimeObject()
{
List<TraceListener> listeners = new();
foreach (ListenerElement element in this)
{
// At some point, we need to pull out adding/removing the 'default' DefaultTraceListener
// code from here in favor of adding/not-adding after we load the config (in TraceSource
// and in static Trace).
listeners.Add(element.GetRuntimeObject());
}
return listeners;
}
protected internal override void InitializeDefault() => InitializeDefaultInternal();
internal void InitializeDefaultInternal()
{
ListenerElement defaultListener = new ListenerElement(false);
defaultListener.Name = "Default";
defaultListener.TypeName = typeof(DefaultTraceListener).FullName;
defaultListener._isAddedByDefault = true;
BaseAdd(defaultListener);
}
protected override void BaseAdd(ConfigurationElement element)
{
ListenerElement listenerElement = element as ListenerElement;
Debug.Assert((listenerElement != null), "adding elements other than ListenerElement to ListenerElementsCollection?");
if (listenerElement.Name.Equals("Default") && listenerElement.TypeName.Equals(typeof(DefaultTraceListener).FullName))
BaseAdd(listenerElement, false);
else
BaseAdd(listenerElement, ThrowOnDuplicate);
}
}
// This is the collection used by the sharedListener section. It is only slightly different from ListenerElementsCollection.
// The differences are that it does not allow remove and clear, and that the ListenerElements it creates do not allow
// references.
[ConfigurationCollection(typeof(ListenerElement),
AddItemName = "add",
CollectionType = ConfigurationElementCollectionType.BasicMap)]
internal sealed class SharedListenerElementsCollection : ListenerElementsCollection
{
public override ConfigurationElementCollectionType CollectionType => ConfigurationElementCollectionType.BasicMap;
protected override ConfigurationElement CreateNewElement() => new ListenerElement(false);
protected override string ElementName => "add";
}
internal sealed class ListenerElement : TypedElement
{
private static readonly ConfigurationProperty s_propFilter = new("filter", typeof(FilterElement), null, ConfigurationPropertyOptions.None);
private static readonly ConfigurationProperty s_propName = new("name", typeof(string), null, ConfigurationPropertyOptions.IsRequired | ConfigurationPropertyOptions.IsKey);
private static readonly ConfigurationProperty s_propOutputOpts = new("traceOutputOptions", typeof(TraceOptions), TraceOptions.None, ConfigurationPropertyOptions.None);
private readonly ConfigurationProperty _propListenerTypeName;
private readonly bool _allowReferences;
private StringDictionary _attributes;
internal bool _isAddedByDefault;
private static readonly ConditionalWeakTable<TraceListener, string> s_initData = new();
public ListenerElement(bool allowReferences) : base(typeof(TraceListener))
{
_allowReferences = allowReferences;
ConfigurationPropertyOptions flags = ConfigurationPropertyOptions.None;
if (!_allowReferences)
flags |= ConfigurationPropertyOptions.IsRequired;
_propListenerTypeName = new ConfigurationProperty("type", typeof(string), null, flags);
_properties.Remove("type");
_properties.Add(_propListenerTypeName);
_properties.Add(s_propFilter);
_properties.Add(s_propName);
_properties.Add(s_propOutputOpts);
}
public StringDictionary Attributes => _attributes ?? new StringDictionary();
[ConfigurationProperty("filter")]
public FilterElement Filter => (FilterElement)this[s_propFilter];
[ConfigurationProperty("name", IsRequired = true, IsKey = true)]
public string Name
{
get
{
return (string)this[s_propName];
}
set
{
this[s_propName] = value;
}
}
[ConfigurationProperty("traceOutputOptions", DefaultValue = (TraceOptions)TraceOptions.None)]
public TraceOptions TraceOutputOptions
{
get
{
return (TraceOptions)this[s_propOutputOpts];
}
// This is useful when the OM becomes public. In the meantime, this can be utilized via reflection.
set
{
this[s_propOutputOpts] = value;
}
}
[ConfigurationProperty("type")]
public override string TypeName
{
get
{
return (string)this[_propListenerTypeName];
}
set
{
this[_propListenerTypeName] = value;
}
}
public override bool Equals(object compareTo)
{
if (Name.Equals("Default") && TypeName.Equals(typeof(DefaultTraceListener).FullName))
{
// This is a workaround to treat all DefaultTraceListener named 'Default' the same.
// This is needed for the Config.Save to work properly as otherwise config base layers
// above us would run into duplicate 'Default' listener element and perceive it as
// error.
ListenerElement compareToElem = compareTo as ListenerElement;
return (compareToElem != null) && compareToElem.Name.Equals("Default")
&& compareToElem.TypeName.Equals(typeof(DefaultTraceListener).FullName);
}
return base.Equals(compareTo);
}
public override int GetHashCode() => base.GetHashCode();
public TraceListener GetRuntimeObject()
{
if (_runtimeObject != null)
return (TraceListener)_runtimeObject;
try
{
string className = TypeName;
if (string.IsNullOrEmpty(className))
{
// Look it up in SharedListeners.
Debug.Assert(_allowReferences, "_allowReferences must be true if type name is null");
if (_attributes != null || ElementInformation.Properties[s_propFilter.Name].ValueOrigin == PropertyValueOrigin.SetHere || TraceOutputOptions != TraceOptions.None || !string.IsNullOrEmpty(InitData))
{
throw new ConfigurationErrorsException(SR.Format(SR.Reference_listener_cant_have_properties, Name));
}
if (DiagnosticsConfiguration.SharedListeners == null)
{
throw new ConfigurationErrorsException(SR.Format(SR.Reference_to_nonexistent_listener, Name));
}
ListenerElement sharedListener = DiagnosticsConfiguration.SharedListeners[Name];
if (sharedListener == null)
{
throw new ConfigurationErrorsException(SR.Format(SR.Reference_to_nonexistent_listener, Name));
}
_runtimeObject = sharedListener.GetRuntimeObject();
return (TraceListener)_runtimeObject;
}
else
{
// Create a new one.
TraceListener newListener = (TraceListener)BaseGetRuntimeObject();
s_initData.AddOrUpdate(newListener, InitData);
newListener.Name = Name;
TraceUtils.CopyStringDictionary(Attributes, newListener.Attributes);
newListener.TraceOutputOptions = TraceOutputOptions;
if (Filter != null && !string.IsNullOrEmpty(Filter.TypeName))
{
newListener.Filter = Filter.GetRuntimeObject();
}
_runtimeObject = newListener;
return newListener;
}
}
catch (ArgumentException e)
{
throw new ConfigurationErrorsException(SR.Format(SR.Could_not_create_listener, Name), e);
}
}
// Our optional attributes implementation is little convoluted as there is
// no such first class mechanism from the config system. We basically cache
// any "unrecognized" attribute here and serialize it out later.
protected override bool OnDeserializeUnrecognizedAttribute(string name, string value)
{
Attributes.Add(name, value);
return true;
}
// We need to serialize optional attributes here, a better place would have
// been inside SerializeElement but the base class implementation from
// ConfigurationElement doesn't take into account for derived class doing
// extended serialization, it basically writes out child element that
// forces the element closing syntax, so any attribute serialization needs
// to happen before normal element serialization from ConfigurationElement.
// This means we would write out custom attributes ahead of normal ones.
// The other alternative would be to re-implement the entire routine here
// which is an overkill and a maintenance issue.
protected override void PreSerialize(XmlWriter writer)
{
if (_attributes != null)
{
IDictionaryEnumerator e = (IDictionaryEnumerator)_attributes.GetEnumerator();
while (e.MoveNext())
{
string xmlValue = (string)e.Value;
string xmlName = (string)e.Key;
if ((xmlValue != null) && (writer != null))
{
writer.WriteAttributeString(xmlName, xmlValue);
}
}
}
}
// Account for optional attributes from custom listeners.
protected internal override bool SerializeElement(XmlWriter writer, bool serializeCollectionKey)
{
bool DataToWrite = base.SerializeElement(writer, serializeCollectionKey);
DataToWrite = DataToWrite || ((_attributes != null) && (_attributes.Count > 0));
return DataToWrite;
}
protected internal override void Unmerge(ConfigurationElement sourceElement,
ConfigurationElement parentElement,
ConfigurationSaveMode saveMode)
{
base.Unmerge(sourceElement, parentElement, saveMode);
// Unmerge the optional attributes cache as well
ListenerElement le = sourceElement as ListenerElement;
if ((le != null) && (le._attributes != null))
{
_attributes = le._attributes;
}
}
internal void ResetProperties()
{
// Blow away any UnrecognizedAttributes that we have deserialized earlier.
if (_attributes != null)
{
_attributes.Clear();
_properties.Clear();
_properties.Add(_propListenerTypeName);
_properties.Add(s_propFilter);
_properties.Add(s_propName);
_properties.Add(s_propOutputOpts);
}
}
internal TraceListener RefreshRuntimeObject(TraceListener listener)
{
_runtimeObject = null;
try
{
string className = TypeName;
if (string.IsNullOrEmpty(className))
{
// Look it up in SharedListeners and ask the sharedListener to refresh.
Debug.Assert(_allowReferences, "_allowReferences must be true if type name is null");
if (_attributes != null || ElementInformation.Properties[s_propFilter.Name].ValueOrigin == PropertyValueOrigin.SetHere || TraceOutputOptions != TraceOptions.None || !string.IsNullOrEmpty(InitData))
{
throw new ConfigurationErrorsException(SR.Format(SR.Reference_listener_cant_have_properties, Name));
}
if (DiagnosticsConfiguration.SharedListeners == null)
{
throw new ConfigurationErrorsException(SR.Format(SR.Reference_to_nonexistent_listener, Name));
}
ListenerElement sharedListener = DiagnosticsConfiguration.SharedListeners[Name];
if (sharedListener == null)
{
throw new ConfigurationErrorsException(SR.Format(SR.Reference_to_nonexistent_listener, Name));
}
_runtimeObject = sharedListener.RefreshRuntimeObject(listener);
return (TraceListener)_runtimeObject;
}
else
{
// We're the element with the type and initializeData info. First see if those two are the same as they were.
// If not, create a whole new object, otherwise, just update the other properties.
if (Type.GetType(className) != listener.GetType() || InitDataChanged(listener))
{
// Type or initdata changed.
return GetRuntimeObject();
}
else
{
TraceUtils.CopyStringDictionary(Attributes, listener.Attributes);
listener.TraceOutputOptions = TraceOutputOptions;
if (listener.Filter != null)
{
if (ElementInformation.Properties[s_propFilter.Name].ValueOrigin == PropertyValueOrigin.SetHere ||
ElementInformation.Properties[s_propFilter.Name].ValueOrigin == PropertyValueOrigin.Inherited)
{
listener.Filter = Filter.RefreshRuntimeObject(listener.Filter);
}
else
{
listener.Filter = null;
}
}
_runtimeObject = listener;
return listener;
}
}
}
catch (ArgumentException e)
{
throw new ConfigurationErrorsException(SR.Format(SR.Could_not_create_listener, Name), e);
}
}
private bool InitDataChanged(TraceListener listener) => !s_initData.TryGetValue(listener, out string previousInitData)
|| InitData != previousInitData;
}
}
|