/// <summary>
/// Ejecuta consulta de select
/// </summary>
/// <param name="query">La consulta</param>
/// <returns>Datatable con el resultadao</returns>
public System.Data.DataTable executeQuery(String query)
{
DataTable table = new DataTable();
OleDbConnection connection = getConnectionString();
using (connection)
{
try
{
connection.Open();
OleDbCommand command = new OleDbCommand(query, connection);
table.Load(command.ExecuteReader());
return(table);
}
catch (Exception ex)
{
MessageBox.Show("Ocurrió un error durante la consulta a la base de datos " + ex.ToString());
myTraceListener.WriteLine("Ocurrió un error durante la consulta a la base de datos " + ex.ToString());
return(table);
}
finally
{
myTraceListener.Flush();
myTraceListener.Dispose();
}
}
}
public void Test05()
{
string msg1;
string[] names = { string.Empty, new string('a', 100000), "hell0<", "><&" };
string fileName = string.Format("{0}_5.xml", this.GetType().Name);
//Scenario 6: Other interesting string values - empty, very long, interesting characters (ones that will clash with xml like <, >, etc)
try
{
foreach (string name in names)
{
CommonUtilities.DeleteFile(fileName);
_stream = new FileStream(fileName, FileMode.OpenOrCreate, FileAccess.Write);
_textWriter = new TextWriterTraceListener(_stream, name);
Assert.True(_textWriter.Name == name);
msg1 = "HelloWorld";
_textWriter.WriteLine(msg1);
_textWriter.Dispose();
Assert.True(CommonUtilities.TestListenerContent(new Type[] { typeof(TextWriterTraceListener) }, new string[] { fileName }, msg1));
}
}
finally
{
CommonUtilities.DeleteFile(fileName);
}
}
protected virtual void Dispose(bool aDisposing)
{
if (!mDisposed)
{
if (aDisposing)
{
Trace.Close();
if (mFileTraceListener != null)
{
mFileTraceListener.Dispose();
mFileTraceListener = null;
}
if (mLogTraceListener != null)
{
mLogTraceListener.Dispose();
mLogTraceListener = null;
}
disposeLogForm();
}
mDisposed = true;
}
}
/// <summary>
/// Start the logging service
/// </summary>
public override void AddListener(string LogFile)
{
Trace.Listeners.Clear();
try
{
twtl = new TextWriterTraceListener(LogFile);
try
{
ctl = new ConsoleTraceListener(false);
Trace.Listeners.Add(twtl);
Trace.Listeners.Add(ctl);
Trace.AutoFlush = true;
}
finally
{
if (ctl != null)
{
ctl.Dispose();
}
}
}
finally
{
if (twtl != null)
{
twtl.Dispose();
}
}
}
public static void Dispose()
{
if (ts != null)
{
ts.Flush();
ts.Close();
StopTimer();
objStream.Close();
objStream.Dispose();
try
{
objTraceListener.Close();
objTraceListener.Dispose();
}
catch
{
}
if (File.Exists(logFileName))
{
FileStream file = new FileStream(logFileName, FileMode.OpenOrCreate, FileAccess.Write);
file.Close();
}
}
}
//! 로그 쓰기
private void writeLog(string msg)
{
TextWriterTraceListener twtl = null;
try
{
twtl = new TextWriterTraceListener(logFileName);
Trace.Listeners.Clear();
Trace.Listeners.Add(twtl); //!< 스트림을 파일에 쓰도록 리스너 추가
Trace.AutoFlush = true; //!< flush(버퍼에서 스트림으로 쓰기 작업)을 자동으로
Trace.Write(DateTime.Now);
Trace.Write(" "); //!< 날짜와 msg 구분자를 한칸(" ")으로
Trace.WriteLine(msg); //!< 로그를 하나를 쓰면 다음 줄로
Trace.Flush(); //!< 버퍼에서 스트림으로 쓰기 작업
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "오류");
}
finally
{
twtl?.Dispose();
}
}
/// <summary>
/// Starts the trace listners.
/// </summary>
public static void StartTraceListners(string logFilePrefix = "RulePerf")
{
string logFilePath = "{1}-{0}.log".FormatWith(DateTime.Now.ToString("yyyy-MM-ddThh-mm-ssZ"), logFilePrefix);
logFilePath = System.IO.Path.Combine(System.Reflection.Assembly.GetExecutingAssembly().Location, logFilePath);
TextWriterTraceListener textWriterTraceListener = new TextWriterTraceListener(logFilePath, "logListener");
ConsoleTraceListener consoleTraceListener = new ConsoleTraceListener();
////Trace.Listeners.Clear();
if (!Trace.Listeners.Contains(textWriterTraceListener.GetType(), textWriterTraceListener.Name))
{
Trace.Listeners.Add(textWriterTraceListener);
}
else
{
textWriterTraceListener.Dispose();
}
if (!Trace.Listeners.Contains(consoleTraceListener.GetType()))
{
Trace.Listeners.Add(consoleTraceListener);
}
else
{
consoleTraceListener.Dispose();
}
Trace.AutoFlush = true;
}
public void Dispose()
{
Trace.Flush();
Trace.Listeners.Remove(textListener);
textListener?.Dispose();
traceStream?.Dispose();
}
public void Test04()
{
string msg1, name;
name = null;
_fileName = string.Format("{0}_4.xml", this.GetType().Name);
//Scenario 4: name is null -its set as the empty string
try
{
CommonUtilities.DeleteFile(_fileName);
_stream = new FileStream(_fileName, FileMode.OpenOrCreate, FileAccess.Write);
_textWriter = new TextWriterTraceListener(_stream, name);
Assert.True(_textWriter.Name == string.Empty);
msg1 = "HelloWorld";
_textWriter.WriteLine(msg1);
_textWriter.Dispose();
Assert.True(CommonUtilities.TestListenerContent(new Type[] { typeof(TextWriterTraceListener) }, new string[] { _fileName }, msg1));
}
finally
{
CommonUtilities.DeleteFile(_fileName);
}
}
public void Test03()
{
string msg1, name;
name = "MyXMLTraceWriter";
string fileName = string.Format("{0}_3.xml", this.GetType().Name);
//Testing ctor(Stream, string)
//Scenario 3: Vanilla - Pass in a valid name and check with the Name property
try
{
CommonUtilities.DeleteFile(fileName);
_stream = new FileStream(fileName, FileMode.OpenOrCreate, FileAccess.Write);
_textWriter = new TextWriterTraceListener(_stream, name);
Assert.True(_textWriter.Name == name);
msg1 = "HelloWorld";
_textWriter.WriteLine(msg1);
_textWriter.Dispose();
Assert.True(CommonUtilities.TestListenerContent(new Type[] { typeof(TextWriterTraceListener) }, new string[] { fileName }, msg1));
}
finally
{
CommonUtilities.DeleteFile(fileName);
}
}
public void TraceTest01()
{
Refresh("TraceClassTests_TextWriterTraceListener1");
try
{
using (FileStream fs = File.Create("TraceClassTests_TextWriterTraceListener1"))
{
TextWriterTraceListener textTL = new TextWriterTraceListener(fs);
Trace.Listeners.Add(textTL);
Trace.WriteLine("Message start.");
Trace.IndentSize = 2;
Trace.IndentLevel = 2;
Trace.Write("This message should be indented.");
Trace.TraceError("This error not be indented.");
Trace.TraceError("{0}", "This error is indendented");
Trace.TraceWarning("This warning is indented");
Trace.TraceWarning("{0}", "This warning is also indented");
Trace.TraceInformation("This information in indented");
Trace.TraceInformation("{0}", "This information is also indented");
Trace.IndentSize = 0;
Trace.IndentLevel = 0;
Trace.WriteLine("Message end.");
textTL.Dispose();
Assert.True(HelperMethods.CheckStrings("TraceClassTests_TextWriterTraceListener1", String.Format("Message start.\r\n This message should be indented.{0} Error: 0 : This error not be indented.\r\n {0} Error: 0 : This error is indendented\r\n {0} Warning: 0 : This warning is indented\r\n {0} Warning: 0 : This warning is also indented\r\n {0} Information: 0 : This information in indented\r\n {0} Information: 0 : This information is also indented\r\nMessage end.\r\n", "DEFAULT_APPNAME"))); //DEFAULT_APPNAME this a bug which needs to be fixed.
}
}
finally
{
Refresh("TraceClassTests_TextWriterTraceListener1");
}
}
public static void WriteLine(string msg)
{
TextWriterTraceListener output = new TextWriterTraceListener(_logPath, "log");
output.WriteLine(msg);
output.Flush();
output.Dispose();
}
/// <summary>
/// Disposes the specified disposing.
/// </summary>
/// <param name="disposing">The disposing.</param>
/// <remarks></remarks>
protected override void Dispose(bool disposing)
{
base.Dispose(disposing);
if (disposing)
{
listener.Dispose();
}
}
/// <summary>
/// Dispose method
/// </summary>
/// <param name="disposing"></param>
protected override void Dispose(bool disposing)
{
if (disposing)
{
base.Dispose();
textWriterTraceListener.Dispose();
}
}
public static void Cleanup()
{
Trace.WriteLine($"{DateTime.Now.ToString("s")} Integration tests of {ClaimsProviderName} {FileVersionInfo.GetVersionInfo(Assembly.GetAssembly(typeof(ldapcp.LDAPCP)).Location).FileVersion} finished.");
Trace.Flush();
if (logFileListener != null)
{
logFileListener.Dispose();
}
}
public void TestWriteAfterDisposeShouldNotThrow()
{
var target = new TextWriterTraceListener(_stream);
target.Dispose();
target.WriteLine(TestMessage);
target.Write(TestMessage);
target.Flush();
}
public void TestWriteAfterDisposeShouldNotThrow()
{
var target = new TextWriterTraceListener(_stream);
target.Dispose();
target.WriteLine(TestMessage);
target.Write(TestMessage);
target.Flush();
}
static void WriteLogEntry(string logEntry)
{
TextWriterTraceListener myTextListener = new TextWriterTraceListener(System.Console.Out);
Trace.Listeners.Add(myTextListener);
Trace.Write(logEntry);
Trace.Flush();
myTextListener.Dispose();
myTextListener = null;
}
private static void handleUnhandledException(Exception exc)
{
bool useHandler = true;
Trace.WriteLine(exc.ToString());
if (useHandler)
{
FUnhandledExceptionHandler handler = new FUnhandledExceptionHandler(exc);
handler.ApplicationName = AssemblyTitle;
handler.ApplicationVersion = Assembly.GetExecutingAssembly().GetName().Version;
if (app != null)
{
try
{
if (app.CommonCode.CurrentFilename != null)
{
handler.CurrentFilename.Add(app.CommonCode.CurrentFilename);
}
}
catch (NullReferenceException)
{
}
}
if (listener != null)
{
try
{
Debug.Listeners.Remove(listener);
listener.Close();
listener.Dispose();
handler.CurrentFilename.Add(traceFile);
}
catch (Exception excLocal)
{
Trace.WriteLine(excLocal.ToString());
}
}
if (Application.MessageLoop)
{
handler.Show();
}
else
{
Application.Run(handler);
}
}
else
{
MessageBox.Show("Ett allvarligt fel har uppstått: \"" + exc.ToString() + "\"",
"Major Failure",
MessageBoxButtons.OK,
MessageBoxIcon.Stop);
}
//Application.Exit();
}
public string HelloWorld()
{
TextWriterTraceListener list;
Debug.Listeners.Add(list = new TextWriterTraceListener(Server.MapPath("../TraceLog1.txt")));
Debug.Write("hello world " + DateTime.Now.ToString());
Debug.Listeners.Remove(list);
list.Close();
list.Dispose();
return("Hello World");
}
protected override void OnDragOver(DragEventArgs e)
{
endX = e.X;
endY = e.Y;
TextWriterTraceListener list;
Debug.Listeners.Add(list = new TextWriterTraceListener(System.Web.HttpContext.Current.Server.MapPath("../TraceLog1.txt")));
Debug.Write("x: " + startX + " y: " + startY + "; x1: " + endX + " y1: " + endY + DateTime.Now.ToString());
Debug.Listeners.Remove(list);
list.Close();
list.Dispose();
this.Refresh();
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void DisposeTraceListeners()
{
LoggingUtils.PrintFunction();
Trace.Flush();
if (m_traceWriterListener != null)
{
Trace.Listeners.Remove(m_traceWriterListener);
m_traceWriterListener.Close();
m_traceWriterListener.Dispose();
}
}
static void Main()
{
#if DEBUG
TextWriterTraceListener listener = new TextWriterTraceListener("debug.log");
Debug.Listeners.Add(listener);
#endif
Console.WriteLine("starting example");
BasicTests win = new BasicTests();
win.VSync = OpenTK.VSyncMode.Adaptive;
win.Run(30);
#if DEBUG
listener.Dispose();
#endif
}
public void Dispose()
{
Trace.TraceInformation("Dispose");
// finalize debug messages
if (listener != null)
{
listener.Flush();
listener.Close();
listener.Dispose();
listener = null;
logFileStream.Close();
logFileStream.Dispose();
}
}
private static void HandleUnhandledException(Exception exc)
{
Trace.WriteLine("Unhandled Exception: " + exc);
var handler = new FUnhandledExceptionHandler(exc)
{
ApplicationName = AssemblyTitle,
ApplicationVersion = Assembly.GetExecutingAssembly().GetName().Version
};
if (_app != null)
{
_app.UnhandledExceptionOccurred = true;
try
{
if (_app.CurrentFilename != null)
{
handler.CurrentFilename.Add(_app.CurrentFilename);
}
}
catch (NullReferenceException)
{
}
}
if (_listener != null)
{
try
{
Debug.Listeners.Remove(_listener);
_listener.Close();
_listener.Dispose();
handler.CurrentFilename.Add(_traceFile);
}
catch (Exception excLocal)
{
Trace.WriteLine(excLocal.ToString());
}
}
if (Application.MessageLoop)
{
handler.Show();
}
else
{
Application.Run(handler);
}
}
protected virtual void Dispose(bool disposing)
{
if (_disposed)
{
return;
}
if (disposing)
{
if (_textWriterTraceListener != null)
{
_textWriterTraceListener.Dispose();
_textWriterTraceListener = null;
}
}
_disposed = true;
}
public void Dispose()
{
_host.Dispose();
foreach (var sourceName in _traceSources)
{
_traceManager[sourceName].Listeners.Remove(_listener);
}
_listener.Dispose();
foreach (var d in Disposables)
{
d.Dispose();
}
}
/// <summary>
/// Allows you to close/open the writer
/// </summary>
public static void Close()
{
if (_traceWriter != null)
{
try
{
Trace.Listeners.Remove(_traceWriter);
_traceWriter.Dispose();
}
catch { }
finally
{
_textWriter = null;
_traceWriter = null;
}
}
}
static void Main()
{
var logger = new TextWriterTraceListener("app.log")
{
TraceOutputOptions = TraceOptions.DateTime
};
Trace.Listeners.Add(logger);
Application.SetHighDpiMode(HighDpiMode.SystemAware);
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new MainForm());
logger.Flush();
logger.Dispose();
}
/// <summary>
/// Function used to start the file stream to which the trace is written.
/// </summary>
private static void InitializeTraceFileStream()
{
//Trace file stream exists, return.
if (m_IsTraceFileStreamInitialized)
{
return;
}
try
{
FileStream traceFileStream = null;
TraceLogFilePolicy traceLogFilePolicy = new TraceLogFilePolicy
(LoggingConstants.CONS_TRACE_FILE_BASE_NAME, m_TraceInfo.FileSizeInMB, LoggingConstants.CONS_TOTAL_TRACE_FILES);
TextWriterTraceListener textWriterTraceListener = null;
try
{
traceFileStream = traceLogFilePolicy.GetLogFileStream();
textWriterTraceListener = new TextWriterTraceListener(traceFileStream);
Trace.Listeners.RemoveAt(0); //Remove the default trace listener
Trace.Listeners.Add(textWriterTraceListener);
m_IsTraceFileStreamInitialized = true;
}
catch (Exception ex)
{
m_TraceInfo.IsTracingEnabled = false;
if (textWriterTraceListener != null)
{
textWriterTraceListener.Dispose();
}
if (traceFileStream != null)
{
traceFileStream.Dispose();
}
throw ex;
}
}
catch (OMEException ObjOMEException)
{
LoggingHelper.ShowOMEMessage(ObjOMEException);
}
catch (Exception ex)
{
LoggingHelper.ShowMessage(ex);
}
}
public virtual void Dispose()
{
if (_listener != null)
{
_listener.Flush();
foreach (var sourceName in _traceSources)
{
_traceManager[sourceName].Listeners.Remove(_listener);
}
_listener.Dispose();
}
foreach (var d in Disposables)
{
d.Dispose();
}
}
