static DefaultTraceListener() { if (!DefaultTraceListener.OnWin32) { string environmentVariable = Environment.GetEnvironmentVariable("MONO_TRACE_LISTENER"); if (environmentVariable != null) { string monoTraceFile; string monoTracePrefix; if (environmentVariable.StartsWith("Console.Out")) { monoTraceFile = "Console.Out"; monoTracePrefix = DefaultTraceListener.GetPrefix(environmentVariable, "Console.Out"); } else if (environmentVariable.StartsWith("Console.Error")) { monoTraceFile = "Console.Error"; monoTracePrefix = DefaultTraceListener.GetPrefix(environmentVariable, "Console.Error"); } else { monoTraceFile = environmentVariable; monoTracePrefix = string.Empty; } DefaultTraceListener.MonoTraceFile = monoTraceFile; DefaultTraceListener.MonoTracePrefix = monoTracePrefix; } } }
public static void AddFileListener(string path = null) { var listener = new DefaultTraceListener(); listener.Filter = new EventTypeFilter(SourceLevels.All); listener.LogFileName = string.IsNullOrEmpty(path) ? Constants.LogFileName : path; Trace.Listeners.Add(listener); }
public static void setLog(config config, string lv) { //test if (bool.Parse(config.get("IsLogFile"))) { //var name = (args.Length == 0) ? "lv_" : util.getRegGroup(args[0], "(lv\\d+)"); var name = (lv == null) ? "rt_lv_" : lv; var logPath = util.getJarPath()[0] + "/" + name + ".txt"; try { #if DEBUG System.Diagnostics.DefaultTraceListener dtl = (System.Diagnostics.DefaultTraceListener)System.Diagnostics.Debug.Listeners["Default"]; dtl.LogFileName = logPath; #else FileStream fs = new FileStream(logPath, FileMode.Append, FileAccess.Write, FileShare.ReadWrite); var w = new System.IO.StreamWriter(fs); w.AutoFlush = true; System.Console.SetOut(w); #endif } catch (Exception e) { util.debugWriteLine(e.Message + " " + e.StackTrace + " " + e.Source + " " + e.TargetSite); } util.isLogFile = true; } }
public void Start() { // find default listnerer foreach (TraceListener tc in Debug.Listeners) { this.defaultListener = tc as DefaultTraceListener; if (defaultListener != null) break; } // remove default listener if (this.defaultListener != null) Debug.Listeners.Remove(this.defaultListener); // adding custom if (Debug.Listeners.Count > 0) { if (Debug.Listeners[0].GetType() != typeof(DebugMonitorTraceListener)) { Debug.Listeners.Add(this.listener); } } else { Debug.Listeners.Add(this.listener); } }
static Logger() { defaultListener = Trace.Listeners.OfType<TraceListener>().FirstOrDefault(listener => listener is DefaultTraceListener) as DefaultTraceListener; if (defaultListener==null) { defaultListener = new DefaultTraceListener(); Trace.Listeners.Add(defaultListener); } }
public Logging() { // using System.Diagnostics; // がソースファイルの一番上に書かれているものとする // DefaultTraceListenerオブジェクトを取得 drl = (DefaultTraceListener)Trace.Listeners["Default"]; //LogFileNameを変更する drl.LogFileName = logName; }
public DebugMonitorTraceListener() { foreach (TraceListener tc in Debug.Listeners) { this.defaultListener = tc as DefaultTraceListener; if (defaultListener != null) break; } }
public void Stop() { if (this.defaultListener != null) { Debug.Listeners.Add(this.defaultListener); this.defaultListener = null; } Debug.Listeners.Remove(this.listener); }
public DebugMonitorTraceListener(ILoggerService logger) { this.logger = logger; foreach (TraceListener tc in Debug.Listeners) { this.defaultListener = tc as DefaultTraceListener; if (defaultListener != null) break; } }
// 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"]); }
private void WriteDebugString(string message) { if (DefaultTraceListener.OnWin32) { DefaultTraceListener.WriteWindowsDebugString(message); } else { this.WriteMonoTrace(message); } }
static DisableAssertUI() { for (int i = 0; i < System.Diagnostics.Debug.Listeners.Count; i++) { System.Diagnostics.DefaultTraceListener dtl = System.Diagnostics.Debug.Listeners[i] as System.Diagnostics.DefaultTraceListener; if (dtl != null) { dtl.AssertUiEnabled = false; } } }
private static void LogWrite(TraceEventType severity, string message) { if (Logger == null) { using (var listener = new System.Diagnostics.DefaultTraceListener()) listener.WriteLine($"{severity.ToString()}: {message}"); } else { Logger(severity, message); } }
// 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 Window1() { InitializeComponent(); // want a debug assert to pop a dialog. // Remove the original default trace listener. Trace.Listeners.RemoveAt(0); // Create and add a new default trace listener. DefaultTraceListener defaultListener; defaultListener = new DefaultTraceListener(); Trace.Listeners.Add(defaultListener); }
public void TestFixtureSetUp() { // Disable Debug traces Trace.Listeners.Clear(); // Disable Debug assert message boxes using (DefaultTraceListener listener = new DefaultTraceListener()) { listener.AssertUiEnabled = false; Trace.Listeners.Add(listener); } // Restore Debug traces to NUnit's Console.Out tab. Trace.Listeners.Add(new TextWriterTraceListener(Console.Out)); }
static Logger() { // Let's set up debugging, if we're in debug mode! #if DEBUG string debugDir = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments); LogFileName = System.IO.Path.Combine(debugDir, "winamp-cs-debug.txt"); var t = new DefaultTraceListener() { LogFileName = LogFileName }; Trace.Listeners.Clear(); Trace.Listeners.Add(t); #endif }
public Form1() { // // Required for Windows Form Designer support // InitializeComponent(); String logFolder = Path.Combine( Environment.GetFolderPath( Environment.SpecialFolder.ApplicationData ), @"DevAtan" ); String logFile = Path.Combine( logFolder, "Log.txt" ); Trace.Listeners.Clear(); DefaultTraceListener defaultListener; defaultListener = new DefaultTraceListener(); Trace.Listeners.Add( defaultListener ); defaultListener.LogFileName = logFile; }
public void Start() { // find default listnerer foreach (TraceListener tc in Debug.Listeners) { this.defaultListener = tc as DefaultTraceListener; if (defaultListener != null) break; } // remove default listener if (this.defaultListener != null) Debug.Listeners.Remove(this.defaultListener); // adding custom Debug.Listeners.Add(this.listener); }
// Remarks: Both attribute are optional private void AddAssertNode(IDictionary d, XmlNode node) { XmlAttributeCollection c = node.Attributes; string assertuienabled = GetAttribute(c, "assertuienabled", false, node); string logfilename = GetAttribute(c, "logfilename", false, node); ValidateInvalidAttributes(c, node); if (assertuienabled != null) { try { d ["assertuienabled"] = bool.Parse(assertuienabled); } catch (Exception e) { throw new ConfigurationException("The `assertuienabled' attribute must be `true' or `false'", e, node); } } if (logfilename != null) { d ["logfilename"] = logfilename; } DefaultTraceListener dtl = (DefaultTraceListener)configValues.Listeners["Default"]; if (dtl != null) { if (assertuienabled != null) { dtl.AssertUiEnabled = (bool)d ["assertuienabled"]; } if (logfilename != null) { dtl.LogFileName = logfilename; } } if (node.ChildNodes.Count > 0) { ThrowUnrecognizedElement(node.ChildNodes[0]); } }
private TraceListener CreateListener(string listenerName, string typeString, string initializationData) { TraceListener retVal = null; try { nHydrateLog.LogVerbose("CreateListener(string listenerName:{0}, string typeString:{1}, string initializationData:{2})", listenerName, typeString, initializationData); if (typeString == ("System.Diagnostics.TextWriterTraceListener")) { retVal = new TextWriterTraceListener(initializationData); } else if (typeString == ("System.Diagnostics.EventLogTraceListener")) { #if !NETSTANDARD retVal = new EventLogTraceListener(initializationData); #endif } else if (typeString == "System.Diagnostics.DefaultTraceListener") { retVal = new System.Diagnostics.DefaultTraceListener(); } else { var obj = Type.GetType(typeString); if (obj != null) { retVal = (TraceListener)ReflectionHelper.CreateInstance(obj, new object[] { initializationData }); } } if (retVal != null) { retVal.Name = listenerName; } else { throw new nHydrate.Generator.Common.Exceptions.nHydrateException(String.Format("Could not create listener - listenerName:{0}- typeString:{1})", listenerName, typeString)); } } catch { } return(retVal); }
public static void Enable(SourceLevels levels, TraceListener listener) { if (listener == null) { listener = new DefaultTraceListener(); } PresentationTraceSources.Refresh(); foreach (PropertyInfo pi in typeof(PresentationTraceSources).GetProperties(BindingFlags.Static | BindingFlags.Public)) { if (pi.Name == "FreezableSource") continue; if (typeof(TraceSource).IsAssignableFrom(pi.PropertyType)) { TraceSource ts = (TraceSource)pi.GetValue(null, null); ts.Listeners.Add(listener); ts.Switch.Level = levels; } } }
public FilteredDefaultTraceListener(DefaultTraceListener listenerToClone) : base() { base.Filter = listenerToClone.Filter; base.IndentLevel = listenerToClone.IndentLevel; base.IndentSize = listenerToClone.IndentSize; base.TraceOutputOptions = listenerToClone.TraceOutputOptions; }
/// <summary> /// Adds the console, debugger, file, or host listener /// if requested. /// </summary> /// internal void AddTraceListenersToSources(Collection<PSTraceSource> matchingSources) { if (DebuggerListener) { if (_defaultListener == null) { _defaultListener = new DefaultTraceListener(); // Note, this is not meant to be localized. _defaultListener.Name = "Debug"; } AddListenerToSources(matchingSources, _defaultListener); } if (PSHostListener) { if (_hostListener == null) { ((MshCommandRuntime)this.CommandRuntime).DebugPreference = ActionPreference.Continue; _hostListener = new PSHostTraceListener(this); // Note, this is not meant to be localized. _hostListener.Name = "Host"; } AddListenerToSources(matchingSources, _hostListener); } if (FileListener != null) { if (_fileListeners == null) { _fileListeners = new Collection<TextWriterTraceListener>(); FileStreams = new Collection<FileStream>(); Exception error = null; try { Collection<string> resolvedPaths = new Collection<string>(); try { // Resolve the file path ProviderInfo provider = null; resolvedPaths = this.SessionState.Path.GetResolvedProviderPathFromPSPath(FileListener, out provider); // We can only export aliases to the file system if (!provider.NameEquals(this.Context.ProviderNames.FileSystem)) { throw new PSNotSupportedException( StringUtil.Format(TraceCommandStrings.TraceFileOnly, FileListener, provider.FullName)); } } catch (ItemNotFoundException) { // Since the file wasn't found, just make a provider-qualified path out if it // and use that. PSDriveInfo driveInfo = null; ProviderInfo provider = null; string path = this.SessionState.Path.GetUnresolvedProviderPathFromPSPath( FileListener, new CmdletProviderContext(this.Context), out provider, out driveInfo); // We can only export aliases to the file system if (!provider.NameEquals(this.Context.ProviderNames.FileSystem)) { throw new PSNotSupportedException( StringUtil.Format(TraceCommandStrings.TraceFileOnly, FileListener, provider.FullName)); } resolvedPaths.Add(path); } if (resolvedPaths.Count > 1) { throw new PSNotSupportedException(StringUtil.Format(TraceCommandStrings.TraceSingleFileOnly, FileListener)); } string resolvedPath = resolvedPaths[0]; Exception fileOpenError = null; try { if (ForceWrite && System.IO.File.Exists(resolvedPath)) { // remove readonly attributes on the file System.IO.FileInfo fInfo = new System.IO.FileInfo(resolvedPath); if (fInfo != null) { // Save some disk write time by checking whether file is readonly.. if ((fInfo.Attributes & FileAttributes.ReadOnly) == FileAttributes.ReadOnly) { //Make sure the file is not read only fInfo.Attributes &= ~(FileAttributes.ReadOnly); } } } // Trace commands always append..So there is no need to set overwrite with force.. FileStream fileStream = new FileStream(resolvedPath, FileMode.Append, FileAccess.Write, FileShare.ReadWrite); FileStreams.Add(fileStream); // Open the file stream TextWriterTraceListener fileListener = new TextWriterTraceListener(fileStream, resolvedPath); fileListener.Name = FileListener; _fileListeners.Add(fileListener); } catch (IOException ioException) { fileOpenError = ioException; } catch (SecurityException securityException) { fileOpenError = securityException; } catch (UnauthorizedAccessException unauthorized) { fileOpenError = unauthorized; } if (fileOpenError != null) { ErrorRecord errorRecord = new ErrorRecord( fileOpenError, "FileListenerPathResolutionFailed", ErrorCategory.OpenError, resolvedPath); WriteError(errorRecord); } } catch (ProviderNotFoundException providerNotFound) { error = providerNotFound; } catch (System.Management.Automation.DriveNotFoundException driveNotFound) { error = driveNotFound; } catch (NotSupportedException notSupported) { error = notSupported; } if (error != null) { ErrorRecord errorRecord = new ErrorRecord( error, "FileListenerPathResolutionFailed", ErrorCategory.InvalidArgument, FileListener); WriteError(errorRecord); } } foreach (TraceListener listener in _fileListeners) { AddListenerToSources(matchingSources, listener); } } }
internal void AddTraceListenersToSources(Collection<PSTraceSource> matchingSources) { if (this.DebuggerListener) { if (this.defaultListener == null) { this.defaultListener = new DefaultTraceListener(); this.defaultListener.Name = "Debug"; } AddListenerToSources(matchingSources, this.defaultListener); } if (this.PSHostListener != 0) { if (this.hostListener == null) { ((MshCommandRuntime) base.CommandRuntime).DebugPreference = ActionPreference.Continue; this.hostListener = new PSHostTraceListener(this); this.hostListener.Name = "Host"; } AddListenerToSources(matchingSources, this.hostListener); } if (this.FileListener != null) { if (this.fileListeners == null) { this.fileListeners = new Collection<TextWriterTraceListener>(); this.fileStreams = new Collection<FileStream>(); Exception exception = null; try { Collection<string> resolvedProviderPathFromPSPath = new Collection<string>(); try { ProviderInfo provider = null; resolvedProviderPathFromPSPath = base.SessionState.Path.GetResolvedProviderPathFromPSPath(this.file, out provider); if (!provider.NameEquals(base.Context.ProviderNames.FileSystem)) { throw new PSNotSupportedException(StringUtil.Format(TraceCommandStrings.TraceFileOnly, this.file, provider.FullName)); } } catch (ItemNotFoundException) { PSDriveInfo drive = null; ProviderInfo info3 = null; string item = base.SessionState.Path.GetUnresolvedProviderPathFromPSPath(this.file, new CmdletProviderContext(base.Context), out info3, out drive); if (!info3.NameEquals(base.Context.ProviderNames.FileSystem)) { throw new PSNotSupportedException(StringUtil.Format(TraceCommandStrings.TraceFileOnly, this.file, info3.FullName)); } resolvedProviderPathFromPSPath.Add(item); } if (resolvedProviderPathFromPSPath.Count > 1) { throw new PSNotSupportedException(StringUtil.Format(TraceCommandStrings.TraceSingleFileOnly, this.file)); } string path = resolvedProviderPathFromPSPath[0]; Exception exception2 = null; try { if (this.ForceWrite && File.Exists(path)) { FileInfo info4 = new FileInfo(path); if ((info4 != null) && ((info4.Attributes & System.IO.FileAttributes.ReadOnly) == System.IO.FileAttributes.ReadOnly)) { info4.Attributes &= ~System.IO.FileAttributes.ReadOnly; } } FileStream stream = new FileStream(path, FileMode.Append, FileAccess.Write, FileShare.ReadWrite); this.fileStreams.Add(stream); TextWriterTraceListener listener = new TextWriterTraceListener(stream, path) { Name = this.file }; this.fileListeners.Add(listener); } catch (IOException exception3) { exception2 = exception3; } catch (SecurityException exception4) { exception2 = exception4; } catch (UnauthorizedAccessException exception5) { exception2 = exception5; } if (exception2 != null) { ErrorRecord errorRecord = new ErrorRecord(exception2, "FileListenerPathResolutionFailed", ErrorCategory.OpenError, path); base.WriteError(errorRecord); } } catch (ProviderNotFoundException exception6) { exception = exception6; } catch (System.Management.Automation.DriveNotFoundException exception7) { exception = exception7; } catch (NotSupportedException exception8) { exception = exception8; } if (exception != null) { ErrorRecord record2 = new ErrorRecord(exception, "FileListenerPathResolutionFailed", ErrorCategory.InvalidArgument, this.file); base.WriteError(record2); } } foreach (TraceListener listener2 in this.fileListeners) { AddListenerToSources(matchingSources, listener2); } } }
private static IDisposable StartLogStream(ApplicationManager appManager) { LogStreamWaitHandle waitHandle = null; Task task = null; if (Debugger.IsAttached) { // Set to verbose level appManager.SettingsManager.SetValue("trace_level", "4").Wait(); RemoteLogStreamManager mgr = appManager.CreateLogStreamManager("Git"); waitHandle = new LogStreamWaitHandle(mgr.GetStream().Result); task = Task.Factory.StartNew(() => { string line = null; var trace = new DefaultTraceListener(); while ((line = waitHandle.WaitNextLine(-1)) != null) { trace.WriteLine(line); } }); } return new DisposableAction(() => { if (waitHandle != null) { waitHandle.Dispose(); task.Wait(); } }); }
public ILSubfigure () { m_isInitializing = true; // setup trace listener string logfile = System.Configuration.ConfigurationManager.AppSettings["logfile"]; if (!String.IsNullOrEmpty(logfile)) { File.Delete(logfile); DefaultTraceListener defTraceListener = new DefaultTraceListener(); Trace.Listeners.Add(defTraceListener); defTraceListener.LogFileName = logfile; Trace.WriteLine(String.Format("{0} - ILSubfigure.ctor()",DateTime.Now)); } this.Size = new Size(500,400); m_panel = ILPanel.Create(getDefaultDeviceType()); m_panel.DrawInactive = true; if (Trace.IndentLevel > 0) Trace.TraceInformation("{0} - ILSubfigure.ctor() - panel created {1}",DateTime.Now,m_panel.GraphicDeviceType); m_colorbar = new ILColorBar(m_panel.Colormap); m_colorbar.RegisterRangeSource(m_panel.Graphs.Limits); m_panel.ColormapChanged += new EventHandler(m_panel_ColormapChanged); m_title = new ILBorderFitLabel(); m_panel.Graphs.CollectionChanged += new ILGraphCollectionChangedEvent(Graphs_CollectionChanged); SetDefaults(); m_panel.Invalidate(); m_isInitializing = false; }
//========================================================================================= // Constructors //========================================================================================= /// <summary> /// Static class initializer. /// </summary> static Tracer() { // Get the full path to the log file. We'll create a directory in the user's // temp directory for the Votive log. This is to fix SourceForge bug #1122213 // where a non-administrator would have insufficient access to write to the // same directory as the assembly (which is Program Files by default). string tempDir = Path.Combine(Path.GetTempPath(), DirectoryName); if (!Directory.Exists(tempDir)) { try { Directory.CreateDirectory(tempDir); } catch (Exception e) { initializationException = e; return; } } logPath = Path.Combine(tempDir, FileName); // Delete the existing log file by creating a zero-length log file. if (File.Exists(logPath)) { FileStream stream = null; try { stream = File.Open(logPath, FileMode.Truncate, FileAccess.Write, FileShare.Write); } catch (Exception e) { initializationException = e; return; } finally { if (stream != null) { stream.Close(); } } } // We'll use the default listener as our logger. Create it if it doesn't exist. DefaultTraceListener listener = (DefaultTraceListener)Trace.Listeners["Default"]; if (listener == null) { listener = new DefaultTraceListener(); Trace.Listeners.Add(listener); } listener.LogFileName = logPath; Trace.IndentSize = 0; Trace.AutoFlush = true; try { // Write the first line to the trace log to make sure we can write to it. string firstLine = PackageUtility.SafeStringFormatInvariant("Trace started on {0}.", DateTime.Now.ToString(HeaderDateFormat, CultureInfo.InvariantCulture)); Trace.WriteLine(firstLine); } catch (Exception e) { initializationException = e; } }
int IObjectWithSite.SetSite(object site) { this.site = site; if (site != null) { LoadOptions(); var serviceProv = (IServiceProvider)this.site; var guidIWebBrowserApp = Marshal.GenerateGuidForType(typeof(IWebBrowserApp)); // new Guid("0002DF05-0000-0000-C000-000000000046"); var guidIWebBrowser2 = Marshal.GenerateGuidForType(typeof(IWebBrowser2)); // new Guid("D30C1661-CDAF-11D0-8A3E-00C04FC9E26E"); IntPtr intPtr; serviceProv.QueryService(ref guidIWebBrowserApp, ref guidIWebBrowser2, out intPtr); browser = (IWebBrowser2)Marshal.GetObjectForIUnknown(intPtr); ((DWebBrowserEvents2_Event)browser).DocumentComplete += new DWebBrowserEvents2_DocumentCompleteEventHandler(this.OnDocumentComplete); } else { ((DWebBrowserEvents2_Event)browser).DocumentComplete -= new DWebBrowserEvents2_DocumentCompleteEventHandler(this.OnDocumentComplete); browser = null; } //CSVファイル読み込み Csv csvread = new Csv(); dtUri = csvread.CsvReader(@"C:\\IEStylish\\", "URI.csv"); dtl = (DefaultTraceListener)Debug.Listeners["Default"]; dtl.LogFileName = @"c:\IEStylish\debug.txt"; return 0; }
/// <summary> /// Method to disable the assertion UI. /// </summary> private void Disable(bool disableAssertUI, bool throwExceptions) { // Get the default listener. TraceListener listener = Trace.Listeners[DefaultTraceListener]; _defaultListener = listener as DefaultTraceListener; if (_defaultListener != null) { // Store the listeners previous value. _previousAssertUIEnabledValue = _defaultListener.AssertUiEnabled; // Disable the assertion UI. _defaultListener.AssertUiEnabled = !disableAssertUI; } // Get the exception convertor listener. listener = Trace.Listeners[ExceptionConvertorListener.ExceptionConvertorListnerName]; _exceptionConvetor = listener as ExceptionConvertorListener; if (_exceptionConvetor == null) { var convertorListener = new ExceptionConvertorListener(throwExceptions); _previousThrowExcpetionsValue = false; Trace.Listeners.Add(convertorListener); } else { _previousThrowExcpetionsValue = _exceptionConvetor.ThrowExceptions; _exceptionConvetor.ThrowExceptions = throwExceptions; } }
private TraceListener CreateListener(string listenerName, string typeString) { TraceListener retVal = null; try { nHydrateLog.LogVerbose("CreateListener(string listenerName:{0}, string typeString:{1})", listenerName, typeString); if (typeString == ("System.Diagnostics.DefaultTraceListener")) { retVal = new DefaultTraceListener(); } else if (typeString == ("System.Diagnostics.EventLogTraceListener")) { retVal = new EventLogTraceListener(); } else { retVal = (TraceListener)ReflectionHelper.CreateInstance(Type.GetType(typeString)); } if (retVal != null) { retVal.Name = listenerName; } else { throw new nHydrate.Generator.Common.Exceptions.nHydrateException(String.Format("Could not create listener - listenerName:{0}- typeString:{1})", listenerName, typeString)); } } catch { } return retVal; }
public void Init(bool useDebugOutput, bool useCrForWriteLine) { var dtl = new DefaultTraceListener(); if (useDebugOutput) { Debug.Listeners.Add(this); Debug.Listeners.Add(dtl); } else { Trace.Listeners.Add(this); Trace.Listeners.Add(dtl); } _useCrWl = useCrForWriteLine; }
public void SharedTraceListener() { var sharedTraceListener = new DefaultTraceListener(); var config = new LoggingConfiguration(); config.AddLogSource("General").AddTraceListener(sharedTraceListener); config.AddLogSource("Special", SourceLevels.Critical, true, sharedTraceListener); Assert.AreEqual<int>(2, config.LogSources.Count); Assert.AreEqual<string>("General", config.LogSources.First().Name); Assert.AreEqual<string>("Special", config.LogSources.Last().Name); }