/// <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) { }