internal TraceSourceInfo (string name, SourceLevels levels, TraceImplSettings settings) { this.name = name; this.levels = levels; this.listeners = new TraceListenerCollection (false); this.listeners.Add (new DefaultTraceListener(), settings); }
internal TracerConfig(string cfg) { if (string.IsNullOrEmpty(cfg)) { return; } var source = new TraceSource(TraceEnvVarName, SourceLevels.All); this.myListeners = source.Listeners; var parser = new TraceCfgParser(cfg); var newListener = parser.OutDevice; this.myFilters = parser.Filters; this.myNotFilters = parser.NotFilters; if (newListener != null) { // when the App.config _Trace source should be used we do not replace // anything if (!parser.UseAppConfigListeners) { this.myListeners.Clear(); this.myListeners.Add(newListener); } } else { this.myListeners = null; } }
private void TraceConfiguration() { try { //delete the old log file string logPath = Path.Combine(PathHelper.ApplicationPath, "ReflectionStudio.exe.log"); if (File.Exists(logPath)) { File.Delete(logPath); } if (ReflectionStudio.Properties.Settings.Default.UseTraceListener) { //configure the trace System.Diagnostics.Trace.AutoFlush = true; System.Diagnostics.Trace.IndentSize = 2; //configure the text listenner System.Diagnostics.TraceListenerCollection listeners = System.Diagnostics.Trace.Listeners; listeners.Add(new System.Diagnostics.TextWriterTraceListener(logPath, "LOG")); } } catch (Exception error) { Tracer.Error("Reflection Studio.TraceConfiguration", error); } }
internal TraceSourceInfo (string name, SourceLevels levels, TraceImplSettings settings) { this.name = name; this.levels = levels; this.listeners = new TraceListenerCollection (); this.listeners.Add (new DefaultTraceListener() { IndentSize = settings.IndentSize }); }
public TraceHook(TraceSource source) { this.listener = new PassThruListener(); this.collection = source.Listeners; this.lockContext = new object(); source.Listeners.Add(listener); HookupListener(); }
public ServerConnection() { WorldModel = new History(); MessageRecieved += ConnectionMessageRecieved; // I wish there were a public constructor for TraceListenerCollection, but there is not ConstructorInfo constructor = typeof(TraceListenerCollection).GetConstructor( BindingFlags.Instance | BindingFlags.NonPublic, null, new Type[] { }, null); ChatListeners = (TraceListenerCollection)constructor.Invoke(new object[0] { }); }
public ClientSideMessageProcessor(ServerConnection connection, History history) { ServerConnection = connection; History = history; ServerConnection.MessageRecieved += ConnectionMessageRecieved; // I wish there were a public constructor for TraceListenerCollection, but there is not ConstructorInfo constructor = typeof(TraceListenerCollection).GetConstructor( BindingFlags.Instance | BindingFlags.NonPublic, null, new Type[] { }, null); ChatListeners = (TraceListenerCollection)constructor.Invoke(new object[0] { }); }
public void AddRange(TraceListenerCollection value) { if (value == null) { throw new ArgumentNullException("value"); } int count = value.Count; for (int i = 0; i < count; i++) { this.Add(value[i]); } }
// Make sure that the trace configuration is loaded. internal static void Initialize() { // Bail out if already initialized, or called recursively. if(initialized) { return; } initialized = true; // Create the default trace listener. DefaultTraceListener defListener = new DefaultTraceListener(); // Create the initial listeners collection. listeners = new TraceListenerCollection(); listeners.Add(defListener); // Get the diagnostics configuration options. Hashtable options = (Hashtable) ConfigurationSettings.GetConfig ("system.diagnostics", new DiagnosticsConfigurationHandler()); if(options == null) { options = new Hashtable(); } // Process the options for the default trace listener. Object value = options["assertuienabled"]; if(value != null) { defListener.AssertUiEnabled = (bool)value; } value = options["logfilename"]; if(value != null) { defListener.LogFileName = (String)value; } // Process the trace options. value = options["autoflush"]; if(value != null) { autoFlush = (bool)value; } value = options["indentsize"]; if(value != null) { indentSize = (int)value; } switches = (Hashtable)(options["switches"]); }
public TraceSource (string name, SourceLevels sourceLevels) { if (name == null) throw new ArgumentNullException ("name"); Hashtable sources = DiagnosticsConfiguration.Settings ["sources"] as Hashtable; TraceSourceInfo info = sources != null ? sources [name] as TraceSourceInfo : null; source_switch = new SourceSwitch (name); if (info == null) listeners = new TraceListenerCollection (); else { source_switch.Level = info.Levels; listeners = info.Listeners; } }
public TraceListenerCollection GetRuntimeObject() { TraceListenerCollection listeners = new TraceListenerCollection(); bool flag = false; foreach (ListenerElement element in this) { if (!flag && !element._isAddedByDefault) { new SecurityPermission(SecurityPermissionFlag.UnmanagedCode).Demand(); flag = true; } listeners.Add(element.GetRuntimeObject()); } return listeners; }
/// <summary> /// Registers trace listeners to be used by the application. /// Generally web.config is used to do this, but there are special cases. /// </summary> /// <param name="traceListenerCollection"> /// The trace Listener Collection to register trace listeners at. /// </param> public static void RegisterTraceListeners(TraceListenerCollection traceListenerCollection) { // This replaces web.config setting: configuration\system.diagnostics\trace\listeners\add type="Microsoft.WindowsAzure.Diagnostics.DiagnosticMonitorTraceListener, Microsoft.WindowsAzure.Diagnostics, Version=1.8.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" name="AzureDiagnostics" // This is done because DiagnosticMonitorTraceListener class throws exception when not running in azure/devfabric. if (RoleEnvironment.IsAvailable) { // See 'diagnostics.wadcfg' file. It contains all configurations of the DiagnosticMonitor. // It is not needed to configure nor start the DiagnosticMonitor manually in code. // It will be started automatically and will use settings in the 'diagnostics.wadcfg' file. // All we need to do is to add the trace listener. // reference: http://www.windowsazure.com/en-us/develop/net/common-tasks/diagnostics/ // google: https://www.google.com/search?q=diagnostics.wadcfg traceListenerCollection.Add(new DiagnosticMonitorTraceListener()); } }
public RedirectOutput() { _oldOut = Console.Out; _oldError = Console.Error; _oldListeners = Trace.Listeners; StdOut = new StringWriter(CultureInfo.CurrentCulture); Console.SetOut(StdOut); StdError = new StringWriter(CultureInfo.CurrentCulture); Console.SetError(StdError); DebugTrace = new StringWriter(CultureInfo.CurrentCulture); Trace.Listeners.Clear(); Trace.Listeners.Add(new TextWriterTraceListener(DebugTrace)); }
/// <summary> /// Initializes a new instance of the <see cref="Logger"/> class with the specified <paramref name="name"/> and logging <paramref name="level"/>. /// </summary> /// <param name="name">The name of the logger.</param> /// <param name="level">The log level of the logger.</param> /// <param name="listeners">The underlying set of trace listeners.</param> public Logger(String name, SourceLevels level, TraceListenerCollection listeners) { Verify.NotNullOrWhiteSpace(name, nameof(name)); // Create the trace source. traceSource = new TraceSource(name, level); // Configure trace source listeners. traceSource.Listeners.Clear(); traceSource.Listeners.AddRange(listeners); // Determine supported log operations. fatalEnabled = (level & SourceLevels.Critical) == SourceLevels.Critical; errorEnabled = (level & SourceLevels.Error) == SourceLevels.Error; warnEnabled = (level & SourceLevels.Warning) == SourceLevels.Warning; infoEnabled = (level & SourceLevels.Information) == SourceLevels.Information; debugEnabled = (level & SourceLevels.Verbose) == SourceLevels.Verbose; activityEnabled = (level & SourceLevels.ActivityTracing) == SourceLevels.ActivityTracing; traceEnabled = (level & SourceLevels.All) == SourceLevels.All; }
public TraceListenerCollection GetRuntimeObject() { TraceListenerCollection listeners = new TraceListenerCollection(); bool _isDemanded = false; 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) if (!_isDemanded && !element._isAddedByDefault) { // Do a full damand; This will disable partially trusted code from hooking up listeners new SecurityPermission(SecurityPermissionFlag.UnmanagedCode).Demand(); _isDemanded = true; } listeners.Add(element.GetRuntimeObject()); } return listeners; }
private void Initialize() { if (!_initCalled) { lock(this) { if (_initCalled) return; SourceElementsCollection sourceElements = DiagnosticsConfiguration.Sources; if (sourceElements != null) { SourceElement sourceElement = sourceElements[sourceName]; if (sourceElement != null) { if (!String.IsNullOrEmpty(sourceElement.SwitchName)) { CreateSwitch(sourceElement.SwitchType, sourceElement.SwitchName); } else { CreateSwitch(sourceElement.SwitchType, sourceName); if (!String.IsNullOrEmpty(sourceElement.SwitchValue)) internalSwitch.Level = (SourceLevels) Enum.Parse(typeof(SourceLevels), sourceElement.SwitchValue); } listeners = sourceElement.Listeners.GetRuntimeObject(); attributes = new StringDictionary(); TraceUtils.VerifyAttributes(sourceElement.Attributes, GetSupportedAttributes(), this); attributes.contents = sourceElement.Attributes; } else NoConfigInit(); } else NoConfigInit(); _initCalled = true; } } }
private void Initialize() { if (!this._initCalled) { lock (this) { if (!this._initCalled) { SourceElementsCollection sources = DiagnosticsConfiguration.Sources; if (sources != null) { SourceElement element = sources[this.sourceName]; if (element != null) { if (!string.IsNullOrEmpty(element.SwitchName)) { this.CreateSwitch(element.SwitchType, element.SwitchName); } else { this.CreateSwitch(element.SwitchType, this.sourceName); if (!string.IsNullOrEmpty(element.SwitchValue)) { this.internalSwitch.Level = (SourceLevels) Enum.Parse(typeof(SourceLevels), element.SwitchValue); } } this.listeners = element.Listeners.GetRuntimeObject(); this.attributes = new StringDictionary(); TraceUtils.VerifyAttributes(element.Attributes, this.GetSupportedAttributes(), this); this.attributes.ReplaceHashtable(element.Attributes); } else { this.NoConfigInit(); } } else { this.NoConfigInit(); } this._initCalled = true; } } } }
private void NoConfigInit() { _internalSwitch = new SourceSwitch(_sourceName, _switchLevel.ToString()); _listeners = new TraceListenerCollection(); _listeners.Add(new DefaultTraceListener()); }
public void AddRange (TraceListenerCollection value) { InitializeRange (value); listeners.AddRange (value.listeners); }
// This method refreshes all the data from the configuration file, so that updated to the configuration file are mirrored // in the System.Diagnostics.Trace class static internal void Refresh() { lock (critSec) { #if CONFIGURATION_DEP settingsInitialized = false; #endif listeners = null; } InitializeSettings(); }
// This method refreshes all the data from the configuration file, so that updated to the configuration file are mirrored // in the System.Diagnostics.Trace class static internal void Refresh() { lock (critSec) { settingsInitialized = false; listeners = null; } InitializeSettings(); }
public void AddRange(TraceListenerCollection value) { InitializeRange(value); listeners.AddRange(value.listeners); }
public TraceSourceInfo (string name, SourceLevels levels) { this.name = name; this.levels = levels; this.listeners = new TraceListenerCollection (); }
private void NoConfigInit() { this.internalSwitch = new SourceSwitch(this.sourceName, this.switchLevel.ToString()); this.listeners = new TraceListenerCollection(); this.listeners.Add(new DefaultTraceListener()); this.attributes = null; }
// only defines "add" and "remove", but "clear" also works // for add, "name" is required; initializeData is optional; "type" is required in 1.x, optional in 2.0. private void AddTraceListeners (IDictionary d, XmlNode listenersNode, TraceListenerCollection listeners) { #if !TARGET_JVM // There are no attributes on <listeners/> ValidateInvalidAttributes (listenersNode.Attributes, listenersNode); foreach (XmlNode child in listenersNode.ChildNodes) { XmlNodeType t = child.NodeType; if (t == XmlNodeType.Whitespace || t == XmlNodeType.Comment) continue; if (t == XmlNodeType.Element) { XmlAttributeCollection attributes = child.Attributes; string name = null; switch (child.Name) { case "add": AddTraceListener (d, child, attributes, listeners); break; case "remove": name = GetAttribute (attributes, "name", true, child); RemoveTraceListener (name); break; case "clear": configValues.Listeners.Clear (); break; default: ThrowUnrecognizedElement (child); break; } ValidateInvalidAttributes (attributes, child); } else ThrowUnrecognizedNode (child); } #endif }
private void NoConfigInit() { _internalSwitch = new SourceSwitch(_sourceName, _switchLevel.ToString()); _listeners = new TraceListenerCollection(); _listeners.Add(new DefaultTraceListener()); }
static TraceImpl() { listeners = new TraceListenerCollection(true); }
private void AddTraceListener(IDictionary d, XmlNode child, XmlAttributeCollection attributes, TraceListenerCollection listeners) { string name = GetAttribute(attributes, "name", true, child); string type = null; #if CONFIGURATION_DEP type = GetAttribute(attributes, "type", false, child); if (type == null) { // indicated by name. TraceListener shared = GetSharedListeners(d) [name]; if (shared == null) { throw new ConfigurationException(String.Format("Shared trace listener {0} does not exist.", name)); } if (attributes.Count != 0) { throw new ConfigurationErrorsException(string.Format( "Listener '{0}' references a shared " + "listener and can only have a 'Name' " + "attribute.", name)); } listeners.Add(shared, configValues); return; } #else type = GetAttribute(attributes, "type", true, child); #endif Type t = Type.GetType(type); if (t == null) { throw new ConfigurationException(string.Format("Invalid Type Specified: {0}", type)); } object[] args; Type[] types; string initializeData = GetAttribute(attributes, "initializeData", false, child); if (initializeData != null) { args = new object[] { initializeData }; types = new Type[] { typeof(string) }; } else { args = null; types = Type.EmptyTypes; } BindingFlags flags = BindingFlags.Public | BindingFlags.Instance; if (t.Assembly == GetType().Assembly) { flags |= BindingFlags.NonPublic; } ConstructorInfo ctor = t.GetConstructor(flags, null, types, null); if (ctor == null) { throw new ConfigurationException("Couldn't find constructor for class " + type); } TraceListener l = (TraceListener)ctor.Invoke(args); l.Name = name; #if CONFIGURATION_DEP string trace = GetAttribute(attributes, "traceOutputOptions", false, child); if (trace != null) { if (trace != trace.Trim()) { throw new ConfigurationErrorsException(string.Format( "Invalid value '{0}' for 'traceOutputOptions'.", trace), child); } TraceOptions trace_options; try { trace_options = (TraceOptions)Enum.Parse( typeof(TraceOptions), trace); } catch (ArgumentException) { throw new ConfigurationErrorsException(string.Format( "Invalid value '{0}' for 'traceOutputOptions'.", trace), child); } l.TraceOutputOptions = trace_options; } string [] supported_attributes = l.GetSupportedAttributes(); if (supported_attributes != null) { for (int i = 0; i < supported_attributes.Length; i++) { string key = supported_attributes [i]; string value = GetAttribute(attributes, key, false, child); if (value != null) { l.Attributes.Add(key, value); } } } #endif listeners.Add(l, configValues); }
internal void Refresh() { if (!this._initCalled) { this.Initialize(); } else { SourceElementsCollection sources = DiagnosticsConfiguration.Sources; if (sources != null) { SourceElement element = sources[this.Name]; if (element != null) { if ((string.IsNullOrEmpty(element.SwitchType) && (this.internalSwitch.GetType() != typeof(SourceSwitch))) || (element.SwitchType != this.internalSwitch.GetType().AssemblyQualifiedName)) { if (!string.IsNullOrEmpty(element.SwitchName)) { this.CreateSwitch(element.SwitchType, element.SwitchName); } else { this.CreateSwitch(element.SwitchType, this.Name); if (!string.IsNullOrEmpty(element.SwitchValue)) { this.internalSwitch.Level = (SourceLevels) Enum.Parse(typeof(SourceLevels), element.SwitchValue); } } } else if (!string.IsNullOrEmpty(element.SwitchName)) { if (element.SwitchName != this.internalSwitch.DisplayName) { this.CreateSwitch(element.SwitchType, element.SwitchName); } else { this.internalSwitch.Refresh(); } } else if (!string.IsNullOrEmpty(element.SwitchValue)) { this.internalSwitch.Level = (SourceLevels) Enum.Parse(typeof(SourceLevels), element.SwitchValue); } else { this.internalSwitch.Level = SourceLevels.Off; } TraceListenerCollection listeners = new TraceListenerCollection(); foreach (ListenerElement element2 in element.Listeners) { TraceListener listener = this.listeners[element2.Name]; if (listener != null) { listeners.Add(element2.RefreshRuntimeObject(listener)); } else { listeners.Add(element2.GetRuntimeObject()); } } TraceUtils.VerifyAttributes(element.Attributes, this.GetSupportedAttributes(), this); this.attributes = new StringDictionary(); this.attributes.ReplaceHashtable(element.Attributes); this.listeners = listeners; } else { this.internalSwitch.Level = this.switchLevel; this.listeners.Clear(); this.attributes = null; } } } }
internal void Refresh() { if (!_initCalled) { Initialize(); return; } SourceElementsCollection sources = DiagnosticsConfiguration.Sources; if (sources != null) { SourceElement sourceElement = sources[Name]; if (sourceElement != null) { // first check if the type changed if ((String.IsNullOrEmpty(sourceElement.SwitchType) && internalSwitch.GetType() != typeof(SourceSwitch)) || (sourceElement.SwitchType != internalSwitch.GetType().AssemblyQualifiedName)) { if (!String.IsNullOrEmpty(sourceElement.SwitchName)) { CreateSwitch(sourceElement.SwitchType, sourceElement.SwitchName); } else { CreateSwitch(sourceElement.SwitchType, Name); if (!String.IsNullOrEmpty(sourceElement.SwitchValue)) { internalSwitch.Level = (SourceLevels)Enum.Parse(typeof(SourceLevels), sourceElement.SwitchValue); } } } else if (!String.IsNullOrEmpty(sourceElement.SwitchName)) { // create a new switch if the name changed, otherwise just refresh. if (sourceElement.SwitchName != internalSwitch.DisplayName) { CreateSwitch(sourceElement.SwitchType, sourceElement.SwitchName); } else { internalSwitch.Refresh(); } } else { // the switchValue changed. Just update our internalSwitch. if (!String.IsNullOrEmpty(sourceElement.SwitchValue)) { internalSwitch.Level = (SourceLevels)Enum.Parse(typeof(SourceLevels), sourceElement.SwitchValue); } else { internalSwitch.Level = SourceLevels.Off; } } TraceListenerCollection newListenerCollection = new TraceListenerCollection(); foreach (ListenerElement listenerElement in sourceElement.Listeners) { TraceListener listener = listeners[listenerElement.Name]; if (listener != null) { newListenerCollection.Add(listenerElement.RefreshRuntimeObject(listener)); } else { newListenerCollection.Add(listenerElement.GetRuntimeObject()); } } TraceUtils.VerifyAttributes(sourceElement.Attributes, GetSupportedAttributes(), this); attributes = new StringDictionary(); attributes.contents = sourceElement.Attributes; listeners = newListenerCollection; } else { // there was no config, so clear whatever we have. internalSwitch.Level = switchLevel; listeners.Clear(); attributes = null; } } }
public void AddRange(System.Diagnostics.TraceListenerCollection value) { }
public void AddRange(TraceListenerCollection value) { Contract.Requires(value != null); }
//--------------------------------------------------------------------- public static SysDiag.TraceListener[] Copy(SysDiag.TraceListenerCollection listeners) { SysDiag.TraceListener[] array = new SysDiag.TraceListener[listeners.Count]; listeners.CopyTo(array, 0); return(array); }
// Initialize the world. // // This logically belongs in the static constructor (as it only needs // to be done once), except for one thing: if the .config file has a // syntax error, .NET throws a ConfigurationException. If we read the // .config file in the static ctor, we throw a ConfigurationException // from the static ctor, which results in a TypeLoadException. Oops. // Reading the .config file here will allow the static ctor to // complete successfully, allowing us to throw a normal // ConfigurationException should the .config file contain an error. // // There are also some ordering issues. // // The DiagnosticsConfigurationHandler assumes that the TraceImpl.Listeners // collection exists (so it can initialize the DefaultTraceListener and // add/remove existing listeners). private static object InitOnce() { object d = null; #if !NO_LOCK_FREE // The lock-free version if (listeners == null) { var c = new TraceListenerCollection(); Thread.MemoryBarrier(); while (Interlocked.CompareExchange(ref listeners, c, null) == null) { // Read in the .config file and get the ball rolling... // d = DiagnosticsConfiguration.Settings; } Thread.MemoryBarrier(); } #else // The lock version (saved for posterity and potential debugging) lock (lock_) { if (listeners == null) { listeners = new TraceListenerCollection (); // Read in the .config file and get the ball rolling... d = DiagnosticsConfiguration.Settings; } } #endif return d; }
private TraceListenerCollection GetSharedListeners (IDictionary d) { TraceListenerCollection shared_listeners = d ["sharedListeners"] as TraceListenerCollection; if (shared_listeners == null) { shared_listeners = new TraceListenerCollection (false); d ["sharedListeners"] = shared_listeners; } return shared_listeners; }
static TraceImpl () { listeners = new TraceListenerCollection (true); }
private void AddTraceListener (IDictionary d, XmlNode child, XmlAttributeCollection attributes, TraceListenerCollection listeners) { string name = GetAttribute (attributes, "name", true, child); string type = null; #if NET_2_0 && CONFIGURATION_DEP type = GetAttribute (attributes, "type", false, child); if (type == null) { // indicated by name. TraceListener shared = GetSharedListeners (d) [name]; if (shared == null) throw new ConfigurationException (String.Format ("Shared trace listener {0} does not exist.", name)); if (attributes.Count != 0) throw new ConfigurationErrorsException (string.Format ( "Listener '{0}' references a shared " + "listener and can only have a 'Name' " + "attribute.", name)); listeners.Add (shared, configValues); return; } #else type = GetAttribute (attributes, "type", true, child); #endif Type t = Type.GetType (type); if (t == null) throw new ConfigurationException (string.Format ("Invalid Type Specified: {0}", type)); object[] args; Type[] types; string initializeData = GetAttribute (attributes, "initializeData", false, child); if (initializeData != null) { args = new object[] { initializeData }; types = new Type[] { typeof(string) }; } else { args = null; types = Type.EmptyTypes; } BindingFlags flags = BindingFlags.Public | BindingFlags.Instance; if (t.Assembly == GetType ().Assembly) flags |= BindingFlags.NonPublic; ConstructorInfo ctor = t.GetConstructor (flags, null, types, null); if (ctor == null) throw new ConfigurationException ("Couldn't find constructor for class " + type); TraceListener l = (TraceListener) ctor.Invoke (args); l.Name = name; #if NET_2_0 && CONFIGURATION_DEP string trace = GetAttribute (attributes, "traceOutputOptions", false, child); if (trace != null) { if (trace != trace.Trim ()) throw new ConfigurationErrorsException (string.Format ( "Invalid value '{0}' for 'traceOutputOptions'.", trace), child); TraceOptions trace_options; try { trace_options = (TraceOptions) Enum.Parse ( typeof (TraceOptions), trace); } catch (ArgumentException) { throw new ConfigurationErrorsException (string.Format ( "Invalid value '{0}' for 'traceOutputOptions'.", trace), child); } l.TraceOutputOptions = trace_options; } string [] supported_attributes = l.GetSupportedAttributes (); if (supported_attributes != null) { for (int i = 0; i < supported_attributes.Length; i++) { string key = supported_attributes [i]; string value = GetAttribute (attributes, key, false, child); if (value != null) l.Attributes.Add (key, value); } } #endif listeners.Add (l, configValues); }
public LogModel(TraceListenerCollection traceListenerCollection) { traceListenerCollection.Add(this); }
// Initialize the world. // // This logically belongs in the static constructor (as it only needs // to be done once), except for one thing: if the .config file has a // syntax error, .NET throws a ConfigurationException. If we read the // .config file in the static ctor, we throw a ConfigurationException // from the static ctor, which results in a TypeLoadException. Oops. // Reading the .config file here will allow the static ctor to // complete successfully, allowing us to throw a normal // ConfigurationException should the .config file contain an error. // // There are also some ordering issues. // // DiagnosticsConfigurationHandler doesn't store values within TraceImpl, // but instead stores values it reads from the .config file within a // TraceImplSettings object (accessible via the TraceImplSettings.Key key // in the IDictionary returned). private static void InitOnce () { if (initLock != null) { lock (initLock) { if (listeners == null) { IDictionary d = DiagnosticsConfiguration.Settings; TraceImplSettings s = (TraceImplSettings) d [TraceImplSettings.Key]; d.Remove (TraceImplSettings.Key); autoFlush = s.AutoFlush; indentLevel = s.IndentLevel; indentSize = s.IndentSize; listeners = s.Listeners; } } initLock = null; } }
public TraceSourceInfo(string name, SourceLevels levels) { this.name = name; this.levels = levels; this.listeners = new TraceListenerCollection(); }