/// <summary>
/// The write log.
/// </summary>
/// <param name="logType">
/// The log type.
/// </param>
/// <param name="message">
/// The message.
/// </param>
/// <param name="errorType">
/// The error type.
/// </param>
public static void WriteLog(LogType logType, string message, LogErrorType errorType = 0)
{
string prefix = null;
var type = errorType;
WriteLog(logType, message, prefix, type);
}
/// <summary>
/// write log to system's event viewer
/// </summary>
/// <param name="errorType">error type</param>
/// <param name="message">error message</param>
private static void LogMsg(LogErrorType errorType, string message)
{
if (!EventLog.SourceExists("SampleProjectConsoleApp"))
{
EventLog.CreateEventSource("SampleProjectConsoleApp", "Application");
}
EventLog log = new EventLog("Application");
log.Source = "SampleProjectConsoleApp";
switch (errorType)
{
case LogErrorType.Error:
log.WriteEntry(message, EventLogEntryType.Error);
break;
case LogErrorType.Warning:
log.WriteEntry(message, EventLogEntryType.Warning);
break;
case LogErrorType.Information:
log.WriteEntry(message, EventLogEntryType.Information);
break;
default:
log.WriteEntry(message, EventLogEntryType.Information);
break;
}
}
/// <summary>Unity Log</summary>
/// <param name="strLog"></param>
/// <param name="color"></param>
/// <param name="ErrorType"></param>
/// <param name="bAddTime"></param>
/// <param name="bSave"></param>
public static void LogAtUnityEditor(string strLog, string color, LogErrorType ErrorType = LogErrorType.Normal, bool bAddTime = true, bool bSave = true)
{
strLog = string.Format("Log : [{0}] {1}", strLog, bAddTime ? DateTime.Now.ToString("yy-MM-dd HH:mm:ss:fff") : "");
if (bSave)
{
arrLog.Add(strLog);
}
if (!MyApplication.IsEditorRuntime())
{
return;
}
string str = UnityColorString(strLog, color);
switch (ErrorType)
{
case LogErrorType.Error:
UnityEngine.Debug.LogError(str);
break;
case LogErrorType.Waring:
UnityEngine.Debug.LogWarning(str);
break;
case LogErrorType.Normal:
UnityEngine.Debug.Log(str);
break;
default:
break;
}
}
/// <summary>
/// The log message_ os log.
/// </summary>
/// <param name="message">
/// The message.
/// </param>
/// <param name="errorType">
/// The error type.
/// </param>
protected virtual void LogMessage_OsLog(string message, LogErrorType errorType)
{
if (!string.IsNullOrEmpty(OsLogName) && !string.IsNullOrEmpty(OsLogSourceName))
{
try
{
EventLogEntryType error;
if (!EventLog.SourceExists(OsLogSourceName))
{
EventLog.CreateEventSource(OsLogSourceName, OsLogName);
}
switch (errorType)
{
case LogErrorType.Error:
case LogErrorType.Exception:
error = EventLogEntryType.Error;
break;
default:
error = EventLogEntryType.Information;
break;
}
EventLog.WriteEntry(OsLogSourceName, message, error);
}
catch (Exception exception)
{
WriteError(LogType.Local, exception, "Исключение при попытке записи в системный журнал");
}
}
}
/// <summary>
/// The log message.
/// </summary>
/// <param name="logType">
/// The log type.
/// </param>
/// <param name="message">
/// The message.
/// </param>
/// <param name="prefix">
/// The prefix.
/// </param>
/// <param name="errorType">
/// The error type.
/// </param>
public void LogMessage(LogType logType, string message, string prefix = "", LogErrorType errorType = 0)
{
message = JoinPrefix(message, prefix);
if (!string.IsNullOrEmpty(message))
{
if ((logType & LogType.Console) == LogType.Console)
{
LogMessage_Console(message, errorType);
}
if ((logType & LogType.Trace) == LogType.Trace)
{
LogMessage_Trace(message, errorType);
}
if ((logType & LogType.OsLog) == LogType.OsLog)
{
LogMessage_OsLog(message, errorType);
}
if ((logType & LogType.Memo) == LogType.Memo)
{
LogMessage_Memo(message, errorType);
}
if ((logType & LogType.File) == LogType.File)
{
LogMessage_File(message, errorType);
}
}
}
/// <summary>
/// Log
/// </summary>
/// <param name="strLog">Log内容</param>
/// <param name="ErrorType">Log错误类型</param>
/// <param name="bAddTime">是否加入时间戳</param>
/// <param name="bSave">是否缓存Log</param>
/// <param name="logPlatform">Log平台</param>
public static void LogAndSave(string strLog, LogErrorType ErrorType = LogErrorType.Normal, bool bAddTime = true, bool bSave = true, LogPlatform logPlatform = LogPlatform.UnityDebug)
{
strLog = string.Format("Log : [{0}] {1}", strLog, bAddTime ? DateTime.Now.ToString("yy-MM-dd HH:mm:ss:fff") : "");
if (bSave)
{
arrLog.Add(strLog);
}
switch (logPlatform)
{
case LogPlatform.UnityDebug:
if (MyApplication.IsEditorRuntime())
{
UnityEngine.Debug.Log(strLog);
}
break;
case LogPlatform.Console:
Console.WriteLine(strLog);
break;
default:
break;
}
}
/// <summary>
/// The write log.
/// </summary>
/// <param name="logType">
/// The log type.
/// </param>
/// <param name="message">
/// The message.
/// </param>
/// <param name="prefix">
/// The prefix.
/// </param>
/// <param name="errorType">
/// The error type.
/// </param>
public static void WriteLog(LogType logType, string message, string prefix, LogErrorType errorType = 0)
{
if (current != null)
{
current.LogMessage(logType, message, prefix, errorType);
}
}
static string AdjustStrLogAtErrorType(string strLog, LogErrorType LogErrorType, LogPlatform logPlatform = LogPlatform.UnityDebug)
{
if (string.IsNullOrEmpty(strLog))
{
return(null);
}
strLog = string.Format("[ErrorType: {0}] {1}", LogErrorType, strLog);
return(strLog);
}
public TextFileLogListener(string filePath, bool writeTimestamp, LogErrorType type)
: base(type)
{
if (!Directory.Exists(Path.GetDirectoryName(filePath)))
{
throw new InstallerVerificationLibraryException("Could not open log file:'" + filePath +
"'. Since one or more of the directories in the path doesn't exist");
}
swriter = new StreamWriter(filePath) {AutoFlush = true};
this.writeTimestamp = writeTimestamp;
}
/// <summary>
/// The log message_ trace.
/// </summary>
/// <param name="message">
/// The message.
/// </param>
/// <param name="errorType">
/// The error type.
/// </param>
protected virtual void LogMessage_Trace(string message, LogErrorType errorType)
{
try
{
Trace.WriteLine(JoinErrorPrefix(message, errorType));
}
catch (Exception exception)
{
WriteError(
LogType.File | LogType.Memo | LogType.Console,
exception,
"Исключение при попытке записи в трассировщик");
}
}
/// <summary>
/// The log message_ file.
/// </summary>
/// <param name="message">
/// The message.
/// </param>
/// <param name="errorType">
/// The error type.
/// </param>
protected virtual void LogMessage_File(string message, LogErrorType errorType)
{
try
{
if (FileLog != null)
{
var bytes = Encoding.Unicode.GetBytes(JoinErrorPrefix(message, errorType) + Environment.NewLine);
FileLog.Write(bytes, 0, bytes.Length);
FileLog.Flush();
}
}
catch (Exception exception)
{
WriteError(LogType.Memo | LogType.Console, exception, "Исключение при попытке записи в журнальный файл");
}
}
/// <summary>
/// The join error prefix.
/// </summary>
/// <param name="message">
/// The message.
/// </param>
/// <param name="errorType">
/// The error type.
/// </param>
/// <returns>
/// The <see cref="string"/>.
/// </returns>
protected string JoinErrorPrefix(string message, LogErrorType errorType)
{
switch (errorType)
{
case LogErrorType.Error:
{
var prefix = "[Error] ";
message = JoinPrefix(message, prefix);
return(message);
}
case LogErrorType.Exception:
{
var str2 = "[Exception] ";
message = JoinPrefix(message, str2);
return(message);
}
}
return(message);
}
/// <summary>
/// The log message_ memo.
/// </summary>
/// <param name="message">
/// The message.
/// </param>
/// <param name="errorType">
/// The error type.
/// </param>
protected virtual void LogMessage_Memo(string message, LogErrorType errorType)
{
}
public TraceLogListener(LogErrorType type, bool writeTimestamp) : base(type)
{
this.writeTimestamp = writeTimestamp;
}
public TraceLogListener(LogErrorType type) : this(type, true)
{
}
private static void WriteToLog(string message, string where, LogErrorType type)
{
var data = new LogData
{
Time = DateTime.Now,
Message = message,
Where = @where,
ErrorType = type,
Indent = indent
};
switch (type)
{
case LogErrorType.Information:
if (InfromationEvent != null) InfromationEvent(data);
break;
case LogErrorType.Warning:
if (WarningEvent != null) WarningEvent(data);
break;
case LogErrorType.Error:
if (ErrorEvent != null) ErrorEvent(data);
break;
default:
throw new ArgumentOutOfRangeException("type", type, null);
}
}
public ConsoleLogListener(LogErrorType type)
: this(type, true)
{
}
protected BaseLogListener(LogErrorType type)
{
ShouldLog = false;
Type = type;
}
/// <summary>
/// The log message_ console.
/// </summary>
/// <param name="message">
/// The message.
/// </param>
/// <param name="errorType">
/// The error type.
/// </param>
protected virtual void LogMessage_Console(string message, LogErrorType errorType)
{
}
/// <summary>
/// The write log.
/// </summary>
/// <param name="message">
/// The message.
/// </param>
/// <param name="prefix">
/// The prefix.
/// </param>
/// <param name="errorType">
/// The error type.
/// </param>
public static void WriteLog(string message, string prefix, LogErrorType errorType = 0)
{
WriteLog(DefaultLogType, message, prefix, errorType);
}
public StreamLogListener(Stream stream, bool writeTimestamp, LogErrorType type)
: base(type)
{
streamWriter = new StreamWriter(stream) {AutoFlush = true};
this.writeTimestamp = writeTimestamp;
}
public DebugLogListener(LogErrorType type) : this(type, true)
{
}
