static Log()
{
_TraceSwitchDebugUI = new TraceSwitch("TraceSwitchDebugUI", "Debug de operações na interface");
_TraceSwitchDebugNg = new TraceSwitch("TraceSwitchDebugNg", "Debug de qualquer operação que não se enquadre no padrão interface");
_TraceSwitchDebugBiblioteca = new TraceSwitch("TraceSwitchDebugBiblioteca", "Debug de operação em biblioteca");
_TraceSwitchGeral = new TraceSwitch("TraceSwitchGeral", "Trace de negocio e dados");
}
internal static void Trace(TraceSwitch traceSwitch, string message)
{
if (traceSwitch != null)
{
Debug.WriteLine(traceSwitch.DisplayName + ": " + message);
}
}
protected DbConnectionPoolCounters(string categoryName, string categoryHelp)
{
AppDomain.CurrentDomain.DomainUnload += new EventHandler(this.UnloadEventHandler);
AppDomain.CurrentDomain.ProcessExit += new EventHandler(this.ExitEventHandler);
AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(this.ExceptionEventHandler);
string instanceName = null;
if (!System.Data.Common.ADP.IsEmpty(categoryName) && System.Data.Common.ADP.IsPlatformNT5)
{
instanceName = this.GetInstanceName();
}
string str2 = categoryName;
this.HardConnectsPerSecond = new Counter(str2, instanceName, CreationData.HardConnectsPerSecond.CounterName, CreationData.HardConnectsPerSecond.CounterType);
this.HardDisconnectsPerSecond = new Counter(str2, instanceName, CreationData.HardDisconnectsPerSecond.CounterName, CreationData.HardDisconnectsPerSecond.CounterType);
this.NumberOfNonPooledConnections = new Counter(str2, instanceName, CreationData.NumberOfNonPooledConnections.CounterName, CreationData.NumberOfNonPooledConnections.CounterType);
this.NumberOfPooledConnections = new Counter(str2, instanceName, CreationData.NumberOfPooledConnections.CounterName, CreationData.NumberOfPooledConnections.CounterType);
this.NumberOfActiveConnectionPoolGroups = new Counter(str2, instanceName, CreationData.NumberOfActiveConnectionPoolGroups.CounterName, CreationData.NumberOfActiveConnectionPoolGroups.CounterType);
this.NumberOfInactiveConnectionPoolGroups = new Counter(str2, instanceName, CreationData.NumberOfInactiveConnectionPoolGroups.CounterName, CreationData.NumberOfInactiveConnectionPoolGroups.CounterType);
this.NumberOfActiveConnectionPools = new Counter(str2, instanceName, CreationData.NumberOfActiveConnectionPools.CounterName, CreationData.NumberOfActiveConnectionPools.CounterType);
this.NumberOfInactiveConnectionPools = new Counter(str2, instanceName, CreationData.NumberOfInactiveConnectionPools.CounterName, CreationData.NumberOfInactiveConnectionPools.CounterType);
this.NumberOfStasisConnections = new Counter(str2, instanceName, CreationData.NumberOfStasisConnections.CounterName, CreationData.NumberOfStasisConnections.CounterType);
this.NumberOfReclaimedConnections = new Counter(str2, instanceName, CreationData.NumberOfReclaimedConnections.CounterName, CreationData.NumberOfReclaimedConnections.CounterType);
string str3 = null;
if (!System.Data.Common.ADP.IsEmpty(categoryName))
{
TraceSwitch switch2 = new TraceSwitch("ConnectionPoolPerformanceCounterDetail", "level of detail to track with connection pool performance counters");
if (TraceLevel.Verbose == switch2.Level)
{
str3 = categoryName;
}
}
this.SoftConnectsPerSecond = new Counter(str3, instanceName, CreationData.SoftConnectsPerSecond.CounterName, CreationData.SoftConnectsPerSecond.CounterType);
this.SoftDisconnectsPerSecond = new Counter(str3, instanceName, CreationData.SoftDisconnectsPerSecond.CounterName, CreationData.SoftDisconnectsPerSecond.CounterType);
this.NumberOfActiveConnections = new Counter(str3, instanceName, CreationData.NumberOfActiveConnections.CounterName, CreationData.NumberOfActiveConnections.CounterType);
this.NumberOfFreeConnections = new Counter(str3, instanceName, CreationData.NumberOfFreeConnections.CounterName, CreationData.NumberOfFreeConnections.CounterType);
}
/// <summary>
/// A constructor.
/// </summary>
public LoggerBase(string filename, System.Diagnostics.TraceLevel level, string eventSource)
{
this.FileName = filename;
traceSwitch = new System.Diagnostics.TraceSwitch(string.Empty, string.Empty);
traceSwitch.Level = level;
this.eventSource = eventSource;
}
/// <summary>
/// Compare the trace levels to determine whether the trace statement will be logged.
/// </summary>
/// <param name="logCategory">Switch name (which is the same as the ACA.NET Logging category name)</param>
/// <param name="tracingLevel">Level of the trace as defined by the trace statement in code</param>
/// <returns>Whether the statement can be logged</returns>
public static bool isLoggable(Category logCategory, int tracingLevel)
{
bool traceStatus = false;
int switchLevel = 0;
// Create an instance of the trace switch
TraceSwitch mySwitch = new TraceSwitch(logCategory.ToString(), "");
// If valid, grab the level
if (mySwitch != null)
switchLevel = TracingLevel(mySwitch.Level);
//else
// throw new ConfigurationException(ERROR_CONFIGURATION_MISSING_SWITCH);
// Compare the levels if valid
if (switchLevel > 0)
{
if (switchLevel >= tracingLevel)
traceStatus = true; // Minimal tracing level met
}
// Tracing is off, disable logging
else
traceStatus = true;
return traceStatus;
}
static Log()
{
Enabled = true;
ShowAll = false;
try
{
traceSwitch = new TraceSwitch("GatewaySwitch", "Configuration level for the gateway trace level.");
traceSource = new TraceSource("GatewaySource");
}
catch
{
}
try
{
// ReSharper disable UnusedVariable
int v = (int)traceSwitch.Level;
// ReSharper restore UnusedVariable
}
catch
{
traceSwitch = null;
}
// Cache all the event types (enumerate the TraceEventType and store it inside a dictionary)
foreach (TraceEventType i in Enum.GetValues(typeof(TraceEventType)))
{
// Due to the debug window
if(i == TraceEventType.Critical || i == TraceEventType.Error || i == TraceEventType.Start || i == TraceEventType.Stop)
cachedWillDisplay.Add(i,true);
else
cachedWillDisplay.Add(i, CalcWillDisplay(i));
}
}
static Logger()
{
TraceSwitch ts = new TraceSwitch("TraceLevelSwitch", "Determines the tracing level to log/display");
TraceLevel = ts.Level;
if (!EventLog.Exists("CSGO"))
{
EventLog.CreateEventSource(LOG_SOURCE, LOG_NAME);
}
try
{
_eventLog = new EventLog();
_eventLog.Source = LOG_SOURCE;
_eventLog.Log = LOG_NAME;
}
catch { }
try
{
_eventLog.MaximumKilobytes = 200 * 1024;
_eventLog.ModifyOverflowPolicy(OverflowAction.OverwriteAsNeeded, 0);
}
catch
{
}
Trace.Listeners.Clear();
Trace.Listeners.Add(new EventLogTraceListener(_eventLog)); // writes to EventLog
Trace.Listeners.Add(new ConsoleTraceListener(true)); // writes to Console window
Trace.Listeners.Add(new DefaultTraceListener()); // writes to Output window
}
static void Main()
{
if (!EventLog.SourceExists("SelfMailer"))
{
EventLog.CreateEventSource("SelfMailer", "Mes applications");
}
EventLog eventLog = new EventLog("Mes applications", ".", "SelfMailer");
eventLog.WriteEntry("Mon message", EventLogEntryType.Warning);
BooleanSwitch booleanSwitch = new BooleanSwitch("BooleanSwitch", "Commutateur booléen.");
TraceSwitch traceSwitch = new TraceSwitch("TraceSwitch", "Commutateur complexe.");
TextWriterTraceListener textListener = new TextWriterTraceListener(@".\Trace.txt");
Trace.Listeners.Add(textListener);
Trace.AutoFlush = true;
Trace.WriteLineIf(booleanSwitch.Enabled, "Démarrage de l'application SelfMailer");
Project = new Library.Project();
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new Forms.Main());
Trace.WriteLineIf(traceSwitch.TraceInfo, "Arrêt de l'application SelfMailer");
}
static Log()
{
TraceSwitch = new TraceSwitch(category, "Trace switch for irelia engine")
{
Level = TraceLevel.Verbose
};
}
public static bool decomp(Stream as_in, Stream as_out, bool ab_trace = false)
{
bool b_result = false;
ts_trace = new TraceSwitch("TOLibSwitch", "Switch for message in TOLib");
if (ab_trace)
ts_trace.Level = TraceLevel.Verbose;
else
ts_trace.Level = TraceLevel.Error;
try
{
using (BinaryReader br_file = new BinaryReader(as_in, Encoding.ASCII, true))
{
byte mode = br_file.ReadByte();
if (mode == 0 || mode == 1 || mode == 3)
{
b_result = decompFile(br_file, as_out, mode);
if (!b_result)
throw new Exception("An error has occurred during decompression.");
}
else
throw new Exception("It's not a correct compression file.");
}
return true;
}
catch (Exception ex)
{
Trace.WriteLine(ex.Message + Environment.NewLine, "ERROR");
return false;
}
}
/// <summary>
/// Initializes the trace/error loggers.
/// </summary>
public static void StartLogging(string dllName)
{
DllName = dllName;
string defaultTraceLevel;
string debugTraceLevel = String.Empty;
try
{
defaultTraceLevel = Utility.GetappSetting("DefaultTracelevel");
debugTraceLevel = Utility.GetappSetting("DebugTraceLevel");
}
catch (CheckedException)
{
defaultTraceLevel = "Info";
}
GetTraceLevel = new TraceSwitch("General", "The Output level of tracing");
DebugLevel = new TraceSwitch("Debug", "The Output Debuglevel of tracing");
// define the datastore for application specific files
string applicationPath;
//dllName = Assembly.GetExecutingAssembly().Location;
applicationPath = Path.GetDirectoryName(dllName);
if (applicationPath.ToUpperInvariant().Contains(@"C:\WINDOWS\MICROSOFT.NET"))
applicationPath = Utility.HomePath;
Debug.WriteLine(applicationPath);
// Create Directory if it doesn't exists
Directory.CreateDirectory(applicationPath);
Directory.CreateDirectory(Path.Combine(applicationPath, "log"));
// define the logging destination
string shortName = Assembly.GetExecutingAssembly().Location;
AppName = Path.GetFileNameWithoutExtension(shortName);
string traceFile = Path.Combine(applicationPath, string.Format(CultureInfo.InvariantCulture,"log\\{0} Trace.log", AppName));
GetErrorFile = Path.Combine(applicationPath, string.Format(CultureInfo.InvariantCulture,"log\\{0} Error.log", AppName));
Debug.WriteLine(traceFile);
Console.WriteLine("traceFile = " + traceFile);
if (GetTraceLevel.Level == TraceLevel.Off || GetTraceLevel.Level == TraceLevel.Error
|| GetTraceLevel.Level == TraceLevel.Warning)
{
Console.WriteLine("TraceLevel set to default.");
Debug.WriteLine("TraceLevel set to default.");
GetTraceLevel = new TraceSwitch("General", "The Output level of tracing", defaultTraceLevel);
DebugLevel = new TraceSwitch("Debug", "The Output Debuglevel of tracing", debugTraceLevel);
//if (m_generalLevel.TraceInfo) InitTraceLog(traceFile);//write application tracing messages.
GetLogFile = null;
GetErrorFile = null;
InitTraceLog(traceFile);
}
else
{
// Use custom logfile and TraceListener if info or verbose was set.
Console.WriteLine("TraceLevel set to info or lower.");
InitTraceLog(traceFile);
}
//CheckTraceLevels();
}
public static void TraceInformation(TraceSwitch traceSwitch, string information)
{
ValidateArgumentIsNull(traceSwitch);
if (traceSwitch.TraceInfo)
{
Trace.TraceInformation(information);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="T:OutputWindowTraceListener"/> class.
/// </summary>
/// <param name="outputWindow">The output window.</param>
/// <param name="traceSwitch">The trace switch.</param>
public OutputWindowTraceListener(IOutputWindowService outputWindow, TraceSwitch traceSwitch)
{
Guard.ArgumentNotNull(outputWindow, "outputWindow");
Guard.ArgumentNotNull(traceSwitch, "traceSwitch");
this.traceSwitch = traceSwitch;
this.outputWindowService = outputWindow;
}
static EventLogger()
{
myTraceSwitch = new TraceSwitch("OptecLogger", "Trace logging for Optec Inc. FocusLynx");
// Set to Verbose by default. Main application should set this to the desired level at runtime.
myTraceSwitch.Level = TraceLevel.Verbose;
SetupEventLogTraceListener();
Trace.WriteLine("Optec EventLogger Initialized - Trace Level = " + LoggingLevel.ToString());
}
static LogHelp()
{
var lister = new TextWriterTraceListener(HttpRuntime.AppDomainAppPath + "staticHtml_log.txt");
lister.TraceOutputOptions = TraceOptions.DateTime;
Trace.Listeners.Add(lister);
Trace.AutoFlush = true;
ts = new TraceSwitch("staticHtml", "staticHtml 日志开关", "2");
}
/// <summary>
/// A constructor.
/// </summary>
public LoggerBase(string filename, string switchName, string eventSource)
{
this.FileName = filename;
switchName = string.IsNullOrEmpty(switchName) ? String.Empty : switchName;
traceSwitch = new System.Diagnostics.TraceSwitch(switchName, string.Empty);
if (switchName.Length == 0)
traceSwitch.Level = System.Diagnostics.TraceLevel.Info;
this.eventSource = eventSource;
}
public static void TraceError(TraceSwitch traceSwitch, Exception exception)
{
ValidateArgumentIsNull(traceSwitch);
ValidateArgumentIsNull(exception);
if (traceSwitch.TraceError)
{
Trace.TraceError(exception.ToString());
}
}
static LogService()
{
TraceSwitch = new TraceSwitch(category, "Trace switch for demacia tool")
{
Level = TraceLevel.Verbose
};
Log.Logged += ((o, e) => LogService.Logged(o, e));
}
/// <summary>
/// Creates a new instance of the <see cref="StreamParser"/> class
/// </summary>
/// <param name="session">A <see cref="TcpIpSession"/></param>
/// <param name="responseQueue">A <see cref="ResponseQueue"/> instance to which <see cref="ResponsePDU"/> pdu's are forwarded</param>
/// <param name="requestProcessor">A callback delegate for processing <see cref="RequestPDU"/> pdu's</param>
public StreamParser(TcpIpSession session, ResponseHandler responseQueue,PduProcessorCallback requestProcessor)
{
if (session == null) { throw new ArgumentNullException("session"); }
if (requestProcessor == null) { throw new ArgumentNullException("requestProcessor"); }
if (responseQueue == null) { throw new ArgumentNullException("responseQueue"); }
vTcpIpSession = session;
vProcessorCallback = requestProcessor;
vResponseHandler = responseQueue;
//--Create and initialize a trace switch
vTraceSwitch = new TraceSwitch("StreamParserSwitch", "Stream perser switch");
}
public LicXLicenseProvider()
{
traceSwitch = new TraceSwitch( "licX", "Trace switches for licX licensing." );
if ( traceSwitch.TraceVerbose )
{
Trace.WriteLine( "----- licX Assembly Details -----" );
Trace.WriteLine( "Assembly: " + Assembly.GetExecutingAssembly() );
Trace.WriteLine( "License Component Type: " + typeof(LicXLicenseComponent).FullName );
Trace.WriteLine( "License Component Guid: " + typeof(LicXLicenseComponent).GUID );
Trace.WriteLine( "----- end Assembly Details -----" );
}
}
public CsTrace(string traceSwitchName) {
_traceApplication = new TraceSwitch(traceSwitchName, "Trace switch for csUnit.");
_traceApplication.Level = ( new CsTraceSettings() ).TraceLevelForSwitch(traceSwitchName);
if( _traceApplication.Level != TraceLevel.Off ) {
string myDocuments = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
string targetFile = Path.Combine(myDocuments, traceSwitchName + ".log.txt");
FileStream myTraceLog = new FileStream(targetFile, FileMode.OpenOrCreate);
TextWriterTraceListener myListener = new TextWriterTraceListener(myTraceLog);
Trace.Listeners.Add(myListener);
Trace.AutoFlush = true;
}
}
static Config()
{
ServerConnectionString = ConfigurationManager.ConnectionStrings["TZeroHost.Properties.Settings.ConfigConn"];
string aux = ConfigurationManager.AppSettings["TerminalZeroClient.Properties.Settings.TerminalCode"];
int auxInt;
int.TryParse(aux, out auxInt);
TerminalCode = auxInt;
TerminalName = System.Environment.MachineName;
IsOnServer = ServerConnectionString != null;
ClientConnectionString = ConfigurationManager.ConnectionStrings["TerminalZeroClient.Properties.Settings.ConfigConn"];
UsersConnectionString = ConfigurationManager.ConnectionStrings["TZeroHost.Properties.Settings.UsersConn"];
LogLevel = new TraceSwitch("ZeroLogLevelSwitch", "Zero Log Level Switch", "Error");
}
private static void LoadTraceLevelFromConfig()
{
_configuration =
(SimpleDataConfigurationSection) ConfigurationManager.GetSection("simpleData/simpleDataConfiguration");
if (_configuration != null)
{
Trace.TraceWarning("SimpleDataConfiguration section is obsolete; use system.diagnostics switches instead.");
TraceLevel = _configuration.TraceLevel;
}
else
{
var traceSwitch = new TraceSwitch("Simple.Data", "", TraceLevel.Info.ToString());
TraceLevel = traceSwitch.Level;
}
}
private nHydrateLog(string exeName)
{
_exeName = exeName;
_currentSwitch = new TraceSwitch("nHydrate", "nHydrate trace switch for " + exeName);
try
{
SetDefaults();
//InitializeConfigFile();
//mAppFileWatcher_Changed(this, new FileSystemEventArgs(WatcherChangeTypes.Changed, _appConfigFile.DirectoryName, _appConfigFile.Name));
}
catch (Exception ex)
{
LogLogFailure(ex.ToString());
}
}
public static void TraceVerbose(TraceSwitch traceSwitch, string format, params object[] args)
{
ValidateArgumentIsNull(traceSwitch);
ValidateArgumentIsNull(args);
if (traceSwitch.TraceVerbose)
{
if (args != null && args.Length > 0)
{
Trace.TraceInformation(format, args);
}
else
{
Trace.TraceInformation(format);
}
}
}
/// <summary>
/// Begin Tracing to log file based on application name.
/// </summary>
public static void InitTracing()
{
if (_traceSwitch == null)
{
_traceSwitch = new TraceSwitch("LoggingLevel", "Controls level of Trace logging output");
if (_traceSwitch.Level != TraceLevel.Off)
{ // if any tracing.. save to log.
//string logName = Path.GetFileNameWithoutExtension(Application.ExecutablePath) + ".log";
logName = Path.Combine(FileUtility.GetLocalApplicationPath(), Path.GetFileNameWithoutExtension(Application.ExecutablePath));
logName = logName + ".log";
FileStream fs = new FileStream(logName, FileMode.Append);
TextWriterTraceListener listener = new TextWriterTraceListener(fs);
Trace.Listeners.Add(listener);
}
Trace.AutoFlush = true;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="Log4netTraceListener"/> class.
/// </summary>
public Log4netTraceListener()
{
this._generalTraceSwitch = new System.Diagnostics.TraceSwitch("TraceLevelSwitch", "Entire application");
this._loggerName = (System.Configuration.ConfigurationManager.AppSettings["log4netLoggerName"] != null)?System.Configuration.ConfigurationManager.AppSettings["log4netLoggerName"].ToString():string.Empty;
// Set default values
this.Name = "Log4net Trace Listener";
// Create additional trace sources list
TraceSourceCollection = new List <TraceSource>();
// Add additional trace sources - .NET framework
//..
// Subscribe to all trace sources
foreach (TraceSource traceSource in TraceSourceCollection)
{
traceSource.Listeners.Add(this);
}
}
public static int Main()
{
System.Diagnostics.TraceSwitch MySwitch = new System.Diagnostics.TraceSwitch("MySwitch", null);
MySwitch.Level = System.Diagnostics.TraceLevel.Verbose;
Console.WriteLine("WMI COM+ Test Application");
//Create a WmiPath object
WmiPath Path = new WmiPath("root\\cimv2");
Console.WriteLine("String in WmiPath object is : {0}", Path.PathString);
//Make a connection to this path
WmiCollection Session = WmiCollection.Connect(Path);
//Get a class from this connection
WmiObject ServiceClass = Session.Get(new WmiPath("Win32_LogicalDisk"));
//WmiObject ServiceClass = Session.Get("Win32_LogicalDisk");
//Display the class name (__CLASS property of the class)
Console.WriteLine("The name of this class is : {0}", ServiceClass["__CLASS"]);
//Enumerate instances
WmiCollection Instances = Session.Open(new WmiPath("Win32_LogicalDisk"));
foreach (WmiObject obj in Instances)
{
Console.WriteLine("The key of this instance is : {0}", obj["Name"]);
}
//Query
WmiCollection QueryRes = Session.Query(new WmiQuery("select * from Win32_Service"));
foreach (WmiObject Service in QueryRes)
{
Console.WriteLine("{0}", Service["Name"]);
}
return(0);
}
/// <summary>
/// 根据跟踪开关和消息级别决定是否向监听器写入消息。
/// </summary>
/// <param name="ts">跟踪开关</param>
/// <param name="level">消息级别</param>
/// <param name="message">消息</param>
public static void Trace(TraceSwitch ts, TraceLevel level, string message)
{
switch (level)
{
case TraceLevel.Error:
TraceError(ts, message);
break;
case TraceLevel.Info:
TraceInformation(ts, message);
break;
case TraceLevel.Off:
break;
case TraceLevel.Verbose:
TraceLine(ts, message);
break;
case TraceLevel.Warning:
TraceWarning(ts, message);
break;
default:
break;
}
}
/// <summary>
/// 构造函数.
/// </summary>
public TestTraceLog()
{
// BooleanSwitch 类型的开关， 只有 一个 Enabled 的 开关定义.
// 构造 跟踪开关.
dataSwitch = new BooleanSwitch("DataMessagesSwitch", "开关定义在配置文件中...");
Console.WriteLine("当前 BooleanSwitch 开关配置：");
Console.WriteLine(" Enabled: {0}", dataSwitch.Enabled);
Console.WriteLine();
// TraceSwitch 类型的开关， 有 Error、Warning、Info、Verbose 四个层次的 开关定义.
// 构造 跟踪开关.
appSwitch = new TraceSwitch("TraceLevelSwitch", "开关定义在配置文件中...");
Console.WriteLine("当前 TraceSwitch 开关配置：");
Console.WriteLine(" TraceError：{0}", appSwitch.TraceError);
Console.WriteLine(" TraceWarning：{0}", appSwitch.TraceWarning);
Console.WriteLine(" TraceInfo：{0}", appSwitch.TraceInfo);
Console.WriteLine(" TraceVerbose：{0}", appSwitch.TraceVerbose);
}
// Define a simple method to write details about the current executing
// environment to the trace listener collection.
public static void WriteEnvironmentInfoToTrace()
{
TraceSwitch ts = new TraceSwitch("configConsoleListener", "switch");
string methodName = "WriteEnvironmentInfoToTrace";
Trace.Indent();
Trace.WriteLine(DateTime.Now.ToString() + " - Start of " + methodName);
Trace.Indent();
// Write details on the executing environment to the trace output.
Trace.WriteLine("Operating system: " + System.Environment.OSVersion.ToString());
Trace.WriteLine("Computer name: " + System.Environment.MachineName);
Trace.WriteLine("User name: " + System.Environment.UserName);
Trace.WriteLine("CLR runtime version: " + System.Environment.Version.ToString());
Trace.WriteLine("Command line: " + System.Environment.CommandLine);
// Enumerate the trace listener collection and
// display details about each configured trace listener.
Trace.WriteLine("Number of configured trace listeners = " + Trace.Listeners.Count.ToString());
#if DEBUG
foreach (TraceListener tl in Trace.Listeners)
{
Trace.WriteLine("Trace listener name = " + tl.Name);
Trace.WriteLine(" type = " + tl.GetType().ToString());
}
#endif
Trace.Unindent();
Trace.WriteLine(DateTime.Now.ToString() + " - End of " + methodName);
Trace.Unindent();
//Trace.Flush();
//Trace.WriteLineIf(
Trace.WriteLineIf(ts.TraceError, "This is a error.");
Trace.WriteLineIf(ts.TraceWarning, "This is a warning.");
Trace.Close();
}
static void Main(string[] args)
{
// Set global exception handler
AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(CurrentDomain_UnhandledException);
// Enable Tracing
TRACE_SWITCH = new TraceSwitch("TraceSwitch", "Default trace switch", "3");
// Get SQL Server configs
string MSSQLConnectionString = ConfigurationManager.ConnectionStrings["MSSQLConnectionString"].ConnectionString;
int SQLBatchSize = int.Parse(ConfigurationManager.AppSettings["SQLBatchSize"]);
int SQLThreads = int.Parse(ConfigurationManager.AppSettings["SQLThreads"]);
// Configure SQL Server spatial types
SqlServerTypes.Utilities.LoadNativeAssemblies(AppDomain.CurrentDomain.BaseDirectory);
// Configure OGR
GdalConfiguration.ConfigureOgr();
Gdal.SetConfigOption("OGR_INTERLEAVED_READING", "YES");
Gdal.SetConfigOption("OSM_COMPRESS_NODES", "YES");
Gdal.SetConfigOption("CPL_TMPDIR", ConfigurationManager.AppSettings["OSMTmpPath"]);
Gdal.SetConfigOption("OSM_MAX_TMPFILE_SIZE", ConfigurationManager.AppSettings["OSMTmpFileSize"]);
Gdal.SetConfigOption("OSM_CONFIG_FILE", ConfigurationManager.AppSettings["OSMConfigFile"]);
DataSource OGRDataSource = Ogr.Open(ConfigurationManager.AppSettings["OSMFile"], 0);
// Drop SQL tables
//DropTables(OGRDataSource, MSSQLConnectionString);
// Create SQL tables and return ADO.NET DataSet of with DataTables
// DataTables will be used buffer records before SQL bulk insert
DataSet OSMDataSet = CreateTables(OGRDataSource, MSSQLConnectionString);
// Start Timer
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
// Do work son!
log(TraceLevel.Info, "Begin Processing...");
DoWork(OGRDataSource, OSMDataSet, MSSQLConnectionString, SQLThreads, SQLBatchSize);
// Create Indexes
CreateIndexes(OGRDataSource, MSSQLConnectionString);
// Stop Timer
stopwatch.Stop();
log(TraceLevel.Info, string.Format("Time elapsed: {0}", stopwatch.Elapsed));
}
public string getTraceLevel(string swtchName)
{
System.Diagnostics.TraceSwitch swtch = new System.Diagnostics.TraceSwitch(swtchName, "asfsjkadhf");
return(swtch.Level.ToString());
}
/// <summary>
/// Construtor padrão.
/// </summary>
/// <param name="name"></param>
/// <param name="description"></param>
public Log(string name, string description)
{
_traceSwitch = new System.Diagnostics.TraceSwitch(name, description);
}
