232 lines
8.8 KiB
C#
232 lines
8.8 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Runtime.CompilerServices;
|
|
using System.Text;
|
|
using System.Threading.Tasks;
|
|
|
|
|
|
namespace XYLEM.Base.Files
|
|
{
|
|
public class ProgramLogCSVFileClass
|
|
{
|
|
private int _LogCountErrors = -1;
|
|
private int _LogCountTotal = -1;
|
|
|
|
public int LogCountErrors { get { return _LogCountErrors; } }
|
|
public int LogCountTotal { get { return _LogCountTotal; } }
|
|
|
|
public string StdLogFilePath = null;
|
|
|
|
public event EventHandler OnErrorIsAdded;
|
|
|
|
#if (!DEBUG)
|
|
public bool DoTimeStamp = false;
|
|
#else
|
|
/*#warning DoTimeStamp is true!!!!!!!!!!!!!!!!
|
|
public bool DoTimeStamp = true;*/
|
|
public bool DoTimeStamp = false;
|
|
#endif
|
|
/// <summary>
|
|
/// init standard program logger
|
|
/// </summary>
|
|
/// <param name="stdLogFolderPath">use a custom log folder or null if use default</param>
|
|
/// <param name="filename">set a custom log file name without extension (ex. "UserCustomLogFile") or null if use default</param>
|
|
public ProgramLogCSVFileClass(string stdLogFolderPath = null, string filename = null)
|
|
{
|
|
if (String.IsNullOrEmpty(filename))
|
|
{
|
|
filename = $"{AppConst.ProductVersion}_program_log";
|
|
}
|
|
if (!string.IsNullOrEmpty(stdLogFolderPath))
|
|
{
|
|
if (!Directory.Exists(stdLogFolderPath))
|
|
{
|
|
PathTools.CreateDirPath(stdLogFolderPath);
|
|
}
|
|
StdLogFilePath=Path.Combine(stdLogFolderPath, filename + ".txt");
|
|
}
|
|
else
|
|
{
|
|
this.StdLogFilePath = Path.Combine(AppConst.ProgramUserFolderRootPath(), filename + ".txt");
|
|
#if (DEBUG)
|
|
Console.WriteLine($"Using standard program log path:\n{this.StdLogFilePath}");
|
|
#endif
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Automated get function name for the function calling this
|
|
/// Used for automating getting a function name to write in a log
|
|
/// </summary>
|
|
/// <param name="inclMsg">Add extra message to log with function name </param>
|
|
/// <returns>"[CALLING_FUNCTION_NAME]() -> [inclMsg]"</returns>
|
|
[MethodImpl(MethodImplOptions.NoInlining)]
|
|
public string GetCurrentMethod(string inclMsg = null)
|
|
{
|
|
var st = new StackTrace();
|
|
var sf = st.GetFrame(1);
|
|
|
|
var nameTxt = $"{sf.GetMethod().Name}()";
|
|
if (!String.IsNullOrEmpty(inclMsg))
|
|
{
|
|
nameTxt += " -> " + inclMsg;
|
|
}
|
|
return nameTxt;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Automated get function name for the function calling this
|
|
/// Used for automating getting a function name to write in a log
|
|
/// </summary>
|
|
/// <param name="inclMsg">Add extra message to log with function name </param>
|
|
/// <returns>"[CALLING_FUNCTION_NAME]() -> [inclMsg]"</returns>
|
|
[MethodImpl(MethodImplOptions.NoInlining)]
|
|
public static string GetCurrentStaticMethod(string inclMsg = null)
|
|
{
|
|
var st = new StackTrace();
|
|
var sf = st.GetFrame(1);
|
|
|
|
var nameTxt = $"{sf.GetMethod().Name}()";
|
|
if (!String.IsNullOrEmpty(inclMsg))
|
|
{
|
|
nameTxt += " -> " + inclMsg;
|
|
}
|
|
return nameTxt;
|
|
}
|
|
|
|
internal void AddToLogFile(bool isError, string nameSingleLine, string infoMultibleLines)
|
|
{
|
|
AddToLogFile(isError, StdLogFilePath, nameSingleLine, infoMultibleLines);
|
|
}
|
|
|
|
internal void AddToLogFile(bool isError, string LogFilePath, string nameSingleLine, string infoMultibleLines)
|
|
{
|
|
try
|
|
{
|
|
if (isError)
|
|
{
|
|
_LogCountErrors++;
|
|
try
|
|
{
|
|
if (OnErrorIsAdded != null)
|
|
{
|
|
OnErrorIsAdded(null, null);
|
|
}
|
|
}
|
|
catch { } // Don't handle this if something breaks down
|
|
}
|
|
_LogCountTotal++;
|
|
if (System.IO.File.Exists(LogFilePath))
|
|
{
|
|
FileInfo f = new FileInfo(LogFilePath);
|
|
if (f.Length > (DoTimeStamp ? 1000000 : 10000))
|
|
{
|
|
f.Delete();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
PathTools.CreateDirPathForFile(LogFilePath);
|
|
}
|
|
var message = infoMultibleLines;
|
|
var length = message.Length;
|
|
File.AppendAllText(LogFilePath, "¤¤¤ " + nameSingleLine.Trim() + " \"" + DateTime.Now.ToString() + "\" ¤¤¤ " + Environment.NewLine
|
|
+ message + Environment.NewLine);
|
|
#if (DEBUG)
|
|
System.Diagnostics.Debug.WriteLine(DateTime.Now.ToString("HH:mm:ss.fff ") +
|
|
" ¤¤¤ " + nameSingleLine.Trim() + " ¤¤¤ " + Environment.NewLine
|
|
+ message
|
|
);
|
|
#endif
|
|
}
|
|
catch (Exception ex)
|
|
{ // Ups just to make sure that this don't result in program is closed
|
|
string test = ex.ToMessageText();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Add a time stamp in program log file.. used to time differend code / controls load time
|
|
/// </summary>
|
|
/// <param name="processObj"> class or window / control obkject to make time stamp for</param>
|
|
/// <param name="desc">description text</param>
|
|
/// <param name="forceLog">Force making log and ignore DoTimeStamp setting</param>
|
|
internal void AddToTimestampLog(object processObj, string desc, bool forceLog = false)
|
|
{
|
|
try
|
|
{
|
|
if (DoTimeStamp || forceLog)
|
|
{
|
|
AddToLogFile(false, StdLogFilePath, processObj.ToString() + DateTime.Now.ToString(" [HH:mm:ss fff]"), desc);
|
|
}
|
|
}
|
|
catch { }
|
|
}
|
|
|
|
internal void AddToProgramLogFile(bool isError, string nameSingleLine, string infoMultibleLines)
|
|
{
|
|
AddToLogFile(isError, StdLogFilePath, nameSingleLine, infoMultibleLines);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Add to program log
|
|
/// </summary>
|
|
/// <param name="ex">Exception to log</param>
|
|
/// <param name="isError">Is an error or just as log</param>
|
|
/// <param name="className">what class or where function is located in</param>
|
|
/// <param name="functionName">what function it was in like "myFunc()" and null if not used</param>
|
|
/// <param name="dataInfo">Additional information also to include like "while doing x and y..."</param>
|
|
internal void ToLog(Exception ex, bool isError, string className, string functionName = null, string dataInfo = null)
|
|
{
|
|
AddToProgramLogFile(isError, LogMessageTool.ToFuncText(isError, className, functionName),
|
|
(String.IsNullOrEmpty(dataInfo) ? "" : dataInfo + ((ex != null) ? Environment.NewLine : "")) // Add data info if used
|
|
+ ((ex != null) ? ex.ToMessageText() : ""));
|
|
}
|
|
|
|
internal void AddFuncLog(bool isError, string className, string functionName, string dataInfo, Exception ex)
|
|
{
|
|
ToLog(ex, isError, className, functionName, dataInfo);
|
|
}
|
|
|
|
internal void AddFuncLog(bool isError, string className, string functionName, Exception ex)
|
|
{
|
|
AddFuncLog(isError, className, functionName, null, ex);
|
|
}
|
|
|
|
internal void AddFuncLog(bool isError, string className, string functionName, string dataInfo)
|
|
{
|
|
AddFuncLog(isError, className, functionName, dataInfo, null);
|
|
}
|
|
|
|
internal void AddClassInitLog(bool isError, string className, Exception ex)
|
|
{
|
|
AddToProgramLogFile(isError, LogMessageTool.ToInitText(isError, className), ((ex != null) ? ex.ToMessageText() : ""));
|
|
}
|
|
|
|
internal void AddClassInitLog(bool isError, string className, string dataInfo, Exception ex)
|
|
{
|
|
AddToProgramLogFile(isError, LogMessageTool.ToInitText(isError, className, dataInfo), ((ex != null) ? ex.ToMessageText() : ""));
|
|
}
|
|
|
|
internal void OpenProgramLogFile()
|
|
{
|
|
OpenLogFile(StdLogFilePath);
|
|
}
|
|
|
|
|
|
internal void OpenLogFile(string LogFilePath)
|
|
{
|
|
try
|
|
{
|
|
Process.Start(LogFilePath);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine("Error Open Log " + Environment.NewLine + ex.ToMessageText());
|
|
}
|
|
}
|
|
}
|
|
} |