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);
}
