Exemple #1
0
 private static void ProcessLog(ELogType type, string message, bool rcon = true)
 {
     AsyncLoggerQueue.Current.Enqueue(new LogEntry()
     {
         Severity = type, Message = message, RCON = rcon
     });
 }
Exemple #2
0
    public static void End(ELogType log_type, string time_check_name)
    {
        int elapsed_time = Environment.TickCount - check_start_time;

        object[] arg = { time_check_name, elapsed_time, ID };
        CDebugLog.LogFormat(log_type, "{0} elapsed_time = {1}ms [ID:{2}]", arg);
    }
        /// <summary>
        /// 把所有的文件开关
        /// </summary>
        /// <param name="eLogType"></param>
        /// <param name="bSwitch"></param>
        public void ChangeAllFileSwitch(ELogType eLogType, bool bSwitch)
        {
            if (this.mConfig == null)
                return;

            this.mConfig.ChangeAllFileSwitch(eLogType, bSwitch);
        }
Exemple #4
0
 internal LoggerEntry(string msg, ELogType level, uint line, string file)
 {
     Message = msg;
     Level   = level;
     Line    = line;
     File    = file;
 }
Exemple #5
0
    static string GetLogTypeStr(ELogType Type)
    {
        switch (Type)
        {
        case ELogType.AStar:
            return("[AStar]");

        case ELogType.Battle:
            return("[Battle]");

        case ELogType.Character:
            return("[Character]");

        case ELogType.GameMode:
            return("[GameMode]");

        case ELogType.MapGenerator:
            return("[MapGenerator]");

        case ELogType.MapObject:
            return("[MapObject]");

        case ELogType.Animation:
            return("[Animation]");
        }
        ;

        return("[Default]");
    }
Exemple #6
0
        public void AddLogEntry(Exception aException, ELogType aELogType, string aSystemName)
        {
            var _SErrorTime = DateTime.Now.ToShortDateString() + " " + DateTime.Now.ToLongTimeString();

            if (!fLogPath.EndsWith("\\"))
            {
                fLogPath = fLogPath + "\\";
            }

            using (var _StreamWriter = new StreamWriter(fLogPath + aSystemName + ".txt", true))
            {
                string _LogFormat = "System Error: " + aException.Message;

                var ToEvalException = aException;
                while (ToEvalException.GetInnerExceptionMessage() != null)
                {
                    if (!ToEvalException.Message.Contains("See the inner exception for details"))
                    {
                        _LogFormat     += "\n" + ToEvalException.GetInnerExceptionMessage();
                        ToEvalException = ToEvalException.InnerException;
                    }
                }
                _LogFormat += "\nDate: " + _SErrorTime;

                _StreamWriter.WriteLine(
                    "--------------------------------------------------------------------------------");
                _StreamWriter.WriteLine(_LogFormat);
                _StreamWriter.WriteLine(
                    "--------------------------------------------------------------------------------");
            }
        }
Exemple #7
0
        public static void Log(int siteId, int channelId, int contentID, string logType, string administratorName, int departmentId)
        {
            var logInfo = new LogInfo(0, siteId, channelId, contentID, departmentId, administratorName, logType, Utils.GetIpAddress(), DateTime.Now, string.Empty);

            var departmentName = DepartmentManager.GetDepartmentName(departmentId);

            ELogType eLogType = ELogTypeUtils.GetEnumType(logType);

            if (eLogType == ELogType.Accept)
            {
                logInfo.Summary = $"{departmentName}({administratorName})受理办件";
            }
            else if (eLogType == ELogType.Deny)
            {
                logInfo.Summary = $"{departmentName}({administratorName})拒绝受理办件";
            }
            else if (eLogType == ELogType.Reply)
            {
                logInfo.Summary = $"{departmentName}({administratorName})回复办件";
            }
            else if (eLogType == ELogType.Comment)
            {
                logInfo.Summary = $"{departmentName}({administratorName})批示办件";
            }
            else if (eLogType == ELogType.Redo)
            {
                logInfo.Summary = $"{departmentName}({administratorName})要求返工";
            }
            else if (eLogType == ELogType.Check)
            {
                logInfo.Summary = $"{departmentName}({administratorName})审核通过";
            }
            LogDao.Insert(logInfo);
        }
Exemple #8
0
        private static void ProcessInternalLog(ELogType type, string message, ConsoleColor color = ConsoleColor.White)
        {
            // OPENMOD PATCH: Use SeriLog
            switch (type)
            {
            case ELogType.Info:
                StandardLogger?.LogInformation(message);
                break;

            case ELogType.Error:
                StandardLogger?.LogError(message);
                break;

            case ELogType.Exception:
                StandardLogger?.LogError(message);
                break;

            case ELogType.Warning:
                StandardLogger?.LogWarning(message);
                break;

            case ELogType.Undefined:
                StandardLogger?.LogInformation(message);
                break;

            default:
                throw new ArgumentOutOfRangeException(nameof(type), type, null);
            }
            // END OPENMOD PATCH: Use SeriLog

            ProcessLog(type, message);
        }
        /// <summary>
        /// 是否打开了开关
        /// </summary>
        /// <param name="eLogType"></param>
        /// <returns></returns>
        public bool IsConsoleSwitch(ELogType eLogType)
        {
            if (!this.mConsoleSwitch.ContainsKey(eLogType))
                return true;

            return this.mConsoleSwitch[eLogType];
        }
        /// <summary>
        /// 修改开关
        /// </summary>
        /// <param name="eLogType"></param>
        /// <param name="bSwitch"></param>
        public void ChangeFileSwitch(ELogType eLogType, bool bSwitch)
        {
            if (!this.mFileSwitch.ContainsKey(eLogType))
                return;

            this.mFileSwitch[eLogType] = bSwitch;
        }
Exemple #11
0
        public override void ActionPrintLog(ELogType type, object message)
        {
            if (!IsDebug)
            {
                return;
            }

            switch (type)
            {
            case ELogType.Info:
                UnityEngine.Debug.Log(message);
                break;

            case ELogType.Warning:
                UnityEngine.Debug.LogWarning(message);
                break;

            case ELogType.Error:
                UnityEngine.Debug.LogError(message);
                break;

            case ELogType.Exception:
                UnityEngine.Debug.LogException((Exception)message);
                break;
            }
        }
Exemple #12
0
        /// <summary>
        /// Запись ошибки в лог-файл
        /// </summary>
        /// <param name="exception">Ошибка</param>
        /// <param name="message">Текст сообщения</param>
        /// <param name="type">Тип сообщения</param>
        public static void WriteException(Exception exception, ELogType type, string message = null)
        {
            //если логгер выключен, то выходим
            if (!_loggerEnabled)
            {
                return;
            }

            //если логгер включен, то пишем в лог-файл
            switch (type)
            {
            case ELogType.Error:
                CurrentLogger.Error(exception, message);
                break;

            case ELogType.Warn:
                CurrentLogger.Warn(exception, message);
                break;

            case ELogType.Info:
                CurrentLogger.Info(exception, message);
                break;

            case ELogType.Debug:
                CurrentLogger.Debug(exception, message);
                break;

            case ELogType.Fatal:
                CurrentLogger.Fatal(exception, message);
                break;

            default:
                throw new ArgumentOutOfRangeException(nameof(type), type, null);
            }
        }
        private void CLog_DidLog(String txt, ELogType logType)
        {
            Color logColor;

            switch (logType)
            {
            case ELogType.CRITICAL_ERROR:
                logColor = Color.Red;
                break;

            case ELogType.GAME_EVENT:
                logColor = Color.Cyan;
                break;

            case ELogType.NETWORK:
                logColor = Color.Azure;
                break;

            default:
                logColor = Color.GreenYellow;
                break;
            }

            rtbMainLog.SelectionColor = Color.Yellow;
            rtbMainLog.AppendText(String.Format("[{0:D02}:{1:D02}:{2:D02}] ", DateTime.Now.Hour, DateTime.Now.Minute, DateTime.Now.Second));

            rtbMainLog.SelectionColor = logColor;
            rtbMainLog.AppendText(txt + "\n");
        }
Exemple #14
0
        private static void ExportLog(ELogType LogType, string Message)
        {
            switch (LogType)
            {
            case ELogType.Fatal:
                LogManager.GetLogger(LogType.ToString()).Fatal(Message);
                break;

            case ELogType.Error:
                LogManager.GetLogger(LogType.ToString()).Error(Message);
                break;

            case ELogType.Warn:
                LogManager.GetLogger(LogType.ToString()).Warn(Message);
                break;

            case ELogType.Debug:
                LogManager.GetLogger(LogType.ToString()).Debug(Message);
                break;

            case ELogType.Info:
                LogManager.GetLogger(LogType.ToString()).Info(Message);
                break;

            default:
                LogManager.GetLogger(typeof(Logging)).Debug(Message);
                break;
            }
        }
 public LogObject(string message, ELogType logType, Dictionary <string, string> parameters = null, string souce = null) : this()
 {
     Message    = message;
     Parameters = parameters;
     LogType    = logType;
     Source     = souce;
 }
Exemple #16
0
 public static void Log(ELogType logType, string message)
 {
     if (_callback != null)
     {
         _callback.Invoke(logType, message);
     }
 }
Exemple #17
0
        public LogProcessor(string name, string group)
        {
            string path = Path.Combine(Path.Combine("log", fFolderMonth), group);
            Directory.CreateDirectory(path);
            fLocation = Path.Combine(path, name);

            //Allow us to set both kLogLeveXXX and xxx as log levels...
            //This is mostly so configuration files will look nicer :)
            string loglev = Configuration.GetString("log_level", "kLogWarning");
            if (Enum.IsDefined(typeof(ELogType), loglev))
                fMinLevel = (ELogType)Enum.Parse(typeof(ELogType), loglev);
            else if (loglev.ToLower() == "error")
                fMinLevel = ELogType.kLogError;
            else if (loglev.ToLower() == "warn")
                fMinLevel = ELogType.kLogWarning;
            else if (loglev.ToLower() == "info")
                fMinLevel = ELogType.kLogInfo;
            else if (loglev.ToLower() == "debug")
                fMinLevel = ELogType.kLogDebug;
            else if (loglev.ToLower() == "verbose")
                fMinLevel = ELogType.kLogVerbose;
            else {
                fMinLevel = ELogType.kLogWarning;
                Error(String.Format("MUd.conf has invalid log_level \"{0}\"", loglev));
            }
        }
Exemple #18
0
 /// <summary>
 /// 输出日志
 /// </summary>
 public static void Log(ELogType logType, string log)
 {
     if (_callback != null)
     {
         _callback.Invoke(logType, log);
     }
 }
Exemple #19
0
        public void CLog(ELogType logType, string message, ConsoleColor color = ConsoleColor.White, bool newLine = true)
        {
            string text = PrefixMsg(message);

            Log(logType, text, null);
            T4GCLog(logType, text, color, newLine);
        }
Exemple #20
0
 public void Log(ELogType type, object log)
 {
     if (IsLogTypeAllowed(type))
     {
         LogHandler.Log(type, log.ToString());
     }
 }
        /// <summary>
        /// 是否写文件日志
        /// </summary>
        /// <param name="strSystemMark"></param>
        /// <returns></returns>
        protected bool IsWriteFile(string strSystemMark, ELogType eLogType)
        {
            if (null == this.mConfig)
                return true;

            return this.mConfig.IsWriteFile(strSystemMark, eLogType);
        }
Exemple #22
0
 public static void AddLog(ELogType type, string function, string message, DateTime time)
 {
     if (EventNewLog != null)
     {
         EventNewLog(message, time);
     }
 }
Exemple #23
0
 public void Log(ELogType t, string format, params object[] args)
 {
     string strData = string.Format(format, args);
     string strAppend = string.Format("[{0}] {1}", t.ToString(), strData + Environment.NewLine);
     int oldLen = LogRichTextBox.Text.Length;
     LogRichTextBox.AppendText(strAppend);
     LogRichTextBox.Select(oldLen, strAppend.Length);
     switch (t)
     {
         case ELogType.INFO:
         case ELogType.DEBUG:
             LogRichTextBox.SelectionColor = Color.Black;
             break;
         case ELogType.ERROR:
         case ELogType.FATAL:
             LogRichTextBox.SelectionColor = Color.Red;
             break;
         case ELogType.WARN:
             LogRichTextBox.SelectionColor = Color.Blue;
             break;
         default:
             break;
     }
     LogRichTextBox.Select(LogRichTextBox.Text.Length, 0);
     LogRichTextBox.SelectionColor = Color.Black;
 }
Exemple #24
0
 public LogEntry(string message, string targetFile, ELogType severity = ELogType.INFO)
 {
     Severity   = severity;
     Message    = message;
     TargetFile = targetFile;
     Timestamp  = DateTime.Now;
 }
Exemple #25
0
        /// <summary>
        /// 记录日志
        /// </summary>
        /// <param name="logType">日志类型</param>
        /// <param name="priority">日志级别</param>
        /// <param name="ex">异常</param>
        /// <param name="message">错误消息</param>
        public static void SaveLog(ELogType logType, ELogPriority priority, string nameSpace, string message, string desc)
        {
            switch (priority)
            {
            case ELogPriority.Trace:
                logger.Trace(const_Error, logType.ToString(), nameSpace, message, desc);
                break;

            case ELogPriority.Debug:
                logger.Debug(const_Error, logType.ToString(), nameSpace, message, desc);
                break;

            case ELogPriority.Inf:
                logger.Info(const_Error, logType.ToString(), nameSpace, message, desc);
                break;

            case ELogPriority.Warn:
                logger.Warn(const_Error, logType.ToString(), nameSpace, message, desc);
                break;

            case ELogPriority.Error:
                logger.Error(const_Error, logType.ToString(), nameSpace, message, desc);
                break;

            case ELogPriority.Fatal:
                logger.Fatal(const_Error, logType.ToString(), nameSpace, message, desc);
                break;
            }
        }
            private string LogTypeName(ELogType type)
            {
                switch (type)
                {
                case ELogType.Critical:
                    return("Critical");

                case ELogType.Error:
                    return("Error");

                case ELogType.Warning:
                    return("Warning");

                case ELogType.Info:
                    return("Info");

                case ELogType.Verbose:
                    return("Verbose");

                case ELogType.Debug:
                    return("Debug");

                default:
                    return(string.Format("<value={0}>", (int)type));
                }
            }
 static public void DisableLog(ELogType eType)
 {
     TLog[(int)eType]        = EmptyLog;
     TLogFormat[(int)eType]  = EmptyLogFormat;
     TLogWarning[(int)eType] = EmptyLog;
     TLogError[(int)eType]   = EmptyLog;
 }
Exemple #28
0
        public static void NowProcess()
        {
            //获取当前进程
            string path = LogPrepare.GetLogPath();

            System.Text.StringBuilder sb = new System.Text.StringBuilder();
            Process cur = Process.GetCurrentProcess();
            string  pn  = cur.ProcessName;//当前运行进程 w3wp/iisexpress

            sb.AppendLine("ProcessName=" + pn);
            string site = cur.Site != null? cur.Site.Name:string.Empty;

            sb.AppendLine("Site=" + site);
            string maiche = cur.MachineName;

            sb.AppendLine("MachineName{.=local}=" + maiche);
            string window = cur.MainWindowTitle;

            sb.AppendLine("MainWindowTitle=" + window);
            string poolName = Environment.GetEnvironmentVariable("APP_POOL_ID", EnvironmentVariableTarget.Process);//应用程序池名称 HrApp/Clr4IntegratedAppPool

            sb.AppendLine("APP_POOL_ID=" + poolName);
            // string json = Newtonsoft.Json.JsonConvert.SerializeObject(cur);
            ELogType lt = ELogType.BackgroundProcess;

            LoggerWriter.CreateLogFile(sb.ToString(), path, lt, LogPrepare.GetLogName(lt), true);
        }
Exemple #29
0
        static void EveryDayDo()
        {
            string path = LogPrepare.GetLogPath();

            try
            {
                StringBuilder text = new StringBuilder();
                text.AppendFormat("Background process【{0}】,index={1} ,time ={2}", GetStartWebOfProcess(), BackRunNumber, DateTime.Now.ToString(Common.Data.CommonFormat.DateTimeFormat));
                ELogType el = ELogType.BackgroundProcess;
                LoggerWriter.CreateLogFile(text.ToString(), path, el, LogPrepare.GetLogName(el), true);
                DoSomeInitEventFacadeFactory dosome = new DoSomeInitEventFacadeFactory();
                dosome.ActiveEmailSmtp();
                //读取xml配置
                string xmlFile = InitAppSetting.DefaultLogPath + "/XmlConfig/AppConfig.xml";
                //执行成功时间写入到xml中
                UiCfgNode.NodeKeyValue = typeof(AppEmailAccount).Name;
                AppEmailAccount appEmail = xmlFile.GetNodeSpecialeAttribute <AppEmailAccount>(UiCfgNode, nodeCfgFormat);
                appEmail.EmailLastActiveTime = DateTime.Now.ToString(Common.Data.CommonFormat.DateTimeFormat);
                appEmail.EmailAccount        = InitAppSetting.AppSettingItemsInDB[EAppSetting.SystemEmailSendBy.ToString()];
                xmlFile.UpdateXmlNode(appEmail, UiCfgNode, nodeCfgFormat);
                LoggerWriter.CreateLogFile(Newtonsoft.Json.JsonConvert.SerializeObject(appEmail), path, el, LogPrepare.GetLogName(el), false);
            }
            catch (Exception ex)
            {
                ELogType el = ELogType.BackgroundProcess;
                LoggerWriter.CreateLogFile("【Error】" + ex.Message.ToString(), path, el, LogPrepare.GetLogName(el), true);
            }
        }
Exemple #30
0
        protected void Application_Start()
        {
            AreaRegistration.RegisterAllAreas();
            WebApiConfig.Register(GlobalConfiguration.Configuration);
            FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
            RouteConfig.RegisterRoutes(RouteTable.Routes);
            GlobalNotifyHandle handle = new GlobalNotifyHandle();
            string             format = Common.Data.CommonFormat.DateTimeMilFormat;
            string             time   = DateTime.Now.ToString(format);
            string             path   = LogPrepare.GetLogPath();
            ELogType           heart  = ELogType.DebugData;
            string             file   = LogPrepare.GetLogName(heart);

            LoggerWriter.CreateLogFile(string.Format("begin init Data  {0}", time), path, heart, file, true);
            Domain.GlobalModel.AppRunData.InitAppData();
            time = DateTime.Now.ToString(format);
            LoggerWriter.CreateLogFile(string.Format("end init Data {0}", time), path, heart, file, true);
            Domain.GlobalModel.AppRunData.AppName = this.GetType().Name;
            time = DateTime.Now.ToString(format);
            LoggerWriter.CreateLogFile(string.Format("begin init ioc {0}", time), path, heart, file, true);
            IocMvcFactoryHelper.GetIocDict(true);
            time = DateTime.Now.ToString(format);
            LoggerWriter.CreateLogFile(string.Format("end init ioc {0}", time), path, heart, file, true);
            InitAppSetting.AppSettingItemsInDB = RefreshAppSetting.QueryAllAppSetting(IocMvcFactoryHelper.GetInterface <IAppSettingService>());
            RefreshAppSetting.RefreshFileVersion();
            AppProcess.GlobalXmlManage();
            AppProcess.CallTodo();
        }
Exemple #31
0
 public static void Log(ELogType logType, string format, params object[] args)
 {
     if (_callback != null)
     {
         string message = string.Format(format, args);
         _callback.Invoke(logType, message);
     }
 }
Exemple #32
0
 public CLogComponent(ELogType type)
 {
     logType = type;
     if (_logObject != null)
     {
         _logManager = _logObject.GetComponent <CLogManager>();
     }
 }
Exemple #33
0
        /// <summary>
        /// Exception
        /// </summary>
        /// <param name="exp">Exception</param>
        /// <param name="LogType">log type</param>
        public static void SaveLog(Exception exp, ELogType LogType)
        {
            string strErrMsg = exp.Message + "\r\n";

            strErrMsg = strErrMsg + "Source:" + exp.Source.ToString() + "\r\n";
            strErrMsg = strErrMsg + "StackTrace:" + exp.StackTrace;
            ExportLog(LogType, strErrMsg);
        }
        public void Log(Type type, ELogType logType, ELogLevel levelType, object data, Exception exception)
        {
            string className = type.FullName;

            string level = GetLevel(levelType);

            Save(Newtonsoft.Json.JsonConvert.SerializeObject(new { Type = GetLogType(logType), Level = level, Class = className, Method = new { exception.TargetSite.Name, exception.TargetSite.DeclaringType }, exception.StackTrace, exception.Message, Time = GetCurrentDateTime(), Data = data }), levelType);
        }
        public void Log(Type type, ELogType logType, ELogLevel levelType, object data, string method)
        {
            string className = type.FullName;

            string level = GetLevel(levelType);

            Save(Newtonsoft.Json.JsonConvert.SerializeObject(new { Type = GetLogType(logType), Level = level, Class = className, Method = method, Time = GetCurrentDateTime(), Data = data }), levelType);
        }
Exemple #36
0
 public static void LogFormat(ELogType Type, string format, params object[] args)
 {
     if (bEnableLog[(int)Type] == true)
     {
         string TypeStr = GetLogTypeStr(Type);
         format = TypeStr + " " + format;
         Debug.LogFormat(format, args);
     }
 }
Exemple #37
0
    protected static string TypeLog(string sIn, ELogType eType)
    {
#if UNITY_EDITOR
        int iType = (int)eType;
        string sOut = string.Format("<color=#{0}>{1}</color><b>{2}</b>", colors[iType], prefixstring[iType], sIn);
        return sOut;
#else
        return sIn;
#endif
    }
Exemple #38
0
        public static void Create(string pMessage, ELogType pType, ELogCategory pCategory)
        {
            if (UnityEngine.Debug.isDebugBuild && !string.IsNullOrEmpty(pMessage))
            {
                var creator = new LogCreator();
                var entry = creator.Create(pMessage, pType, pCategory);

                ShowLog(entry);

                ServiceManager.Instance.GetService<LogService>().AddLogEntry(entry);
            }
        }
Exemple #39
0
        internal LogEntry Create(string pMessage, ELogType pType, ELogCategory pCategory)
        {
            mEntry = new LogEntry()
            {
                LogType = pType,
                Message = pMessage,
                Time = DateTime.Now,
                Category = pCategory
            };

            HandleStackTrace();

            return mEntry;
        }
Exemple #40
0
 public void DumpToLog(string dump, ELogType level)
 {
     if (level <= fMinLevel) DumpToLog(dump);
 }
Exemple #41
0
 public LogEventArgs(ELogType type, string message)
 {
     EventTime = DateTime.Now;
     Type = type;
     Message = message;
 }
Exemple #42
0
        private static void ProcessInternalLog(ELogType type, string message, bool doWriteToConsole = true)
        {
            if (doWriteToConsole)
            {
                if (type == ELogType.Error || type == ELogType.Exception)
                {

                    // Debug.LogError(message);
                    writeToConsole(message, ConsoleColor.Red);
                }
                else if (type == ELogType.Warning)
                {
                    //  Debug.LogWarning(message);
                    writeToConsole(message, ConsoleColor.Yellow);
                }
                else
                {
                    //Debug.Log(message);
                    writeToConsole(message, ConsoleColor.White);
                }
                ProcessLog(type, message);
            }
        }
Exemple #43
0
 private static void ProcessLog(ELogType type, string message,bool rcon = true)
 {
     AsyncLoggerQueue.Current.Enqueue(new LogEntry() { Severity = type, Message = message, RCON = rcon });
 }
Exemple #44
0
        // 输出日志
        public static void WriteLog(ELogType type, string msg)
        {
            using (StreamWriter souts = new StreamWriter(LogFile, true, Encoding.Unicode))
            {
                try
                {
                    switch (type)
                    {
                        case ELogType.Info:
                            {
                                souts.WriteLine(string.Format("[Info]: {0}", msg));
                            }
                            break;
                        case ELogType.Warning:
                            {
                                souts.WriteLine(string.Format("[Warning]: {0}", msg));
                            }
                            break;
                        case ELogType.Error:
                            {
                                souts.WriteLine(string.Format("[Info]: {0}", msg));
                            }
                            break;
                    }
                }
                catch (Exception)
                {

                }
            }
        }
Exemple #45
0
 public static void Create(string pMessage, ELogType pType)
 {
     Create(pMessage, pType, ELogCategory.NONE);
 }
 /// <summary>
 /// 构造函数
 /// </summary>
 /// <param name="logType"></param>
 /// <param name="strContent"></param>
 public LogContent(ELogType logType, string strSystemMark, string strContent)
 {
     LogType = logType;
     Content = strContent;
     SystemMark = strSystemMark;
 }
Exemple #47
0
 public static void updateLog(string txt, ELogLevel level, ELogType whom)
 {
     if (level == ELogLevel.Debug && (whom != ELogType.SpeechRecog && whom != ELogType.Net)) return;
     if (Form1.server.txtLog.InvokeRequired)
     {
         Form1.updateLog_Callback d = new updateLog_Callback(updateLog);
         Form1.server.Invoke(d, new object[] { txt, level, whom });
     }
     else
     {
         System.Diagnostics.Trace.WriteLine(DateTime.Now.ToString("yyMMdd HH:mm:ss: [") +
             level.ToString() + "] " +
             txt);
         Form1.server.txtLog.AppendText(DateTime.Now.ToString("yyMMdd HH:mm:ss: [") +
             level.ToString()+"] " +
             txt + "\n");
     }
 }
Exemple #48
0
 public String format(ELogType type, String message)
 {
     String data = default_format;
     data = data.Replace("{message}", message);
     data = data.Replace("{level}", type.ToString());
     data = data.Replace("{time}", String.Format("{0:HH:mm:ss:fff}",DateTime.Now));
     return data;
 }
Exemple #49
0
 public void log(ELogType type, String message)
 {
     foreach (ILogger logger in loggers) {
         logger.log(type, message);
     }
 }
Exemple #50
0
 public override void log(ELogType type, string message)
 {
     if (type < writeLevel) return;
     if (onLog != null) onLog(type, message);
 }
Exemple #51
0
 public override void log(ELogType type, string message)
 {
     if (type < writeLevel) return;
     Console.WriteLine(base.formatter.format(type, message));
 }
Exemple #52
0
 internal ErrorSeverityAttribute(ELogType pLogType)
 {
     LogType = pLogType;
 }
Exemple #53
0
 public abstract void log(ELogType type, String message);
Exemple #54
0
 private string LogTypeName(ELogType type)
 {
     switch (type)
     {
         case ELogType.Critical:
             return "Critical";
         case ELogType.Error:
             return "Error";
         case ELogType.Warning:
             return "Warning";
         case ELogType.Info:
             return "Info";
         case ELogType.Verbose:
             return "Verbose";
         case ELogType.Debug:
             return "Debug";
         default:
             return string.Format("<value={0}>", (int) type);
     }
 }
Exemple #55
0
 public void DumpToLog(string dump, string msg, ELogType level)
 {
     if (level <= fMinLevel) {
         WriteLine(msg, level);
         DumpToLog(dump);
     }
 }
        /// <summary>
        /// 修改控制台日志开关
        /// </summary>
        /// <param name="strSystemMark"></param>
        /// <param name="eLogType"></param>
        /// <param name="bSwitch"></param>
        public void ChangeConsoleSwitch(string strSystemMark, ELogType eLogType, bool bSwitch)
        {
            if (this.mConfig == null)
                return;

            this.mConfig.ChangeConsoleSwitch(strSystemMark, eLogType, bSwitch);
        }
Exemple #57
0
 public void Log(ELogType type, string format, params object[] args)
 {
     Log(type, (format == null) ? null : string.Format(format, args));
 }
Exemple #58
0
        public void WriteLine(string line, ELogType level)
        {
            if (level <= fMinLevel) {
                string levelstr = "[UNK] ";
                switch (level) {
                    case ELogType.kLogDebug:
                        levelstr = "[DBG] ";
                        break;
                    case ELogType.kLogError:
                        levelstr = "[ERR] ";
                        break;
                    case ELogType.kLogInfo:
                        levelstr = "[INF] ";
                        break;
                    case ELogType.kLogVerbose:
                        levelstr = "[VBS] ";
                        break;
                    case ELogType.kLogWarning:
                        levelstr = "[WRN] ";
                        break;
                }

                IWriteLine(levelstr + line);
            }
        }
Exemple #59
0
 public void DumpToLog(byte[] dump, string msg, ELogType level)
 {
     if (level <= fMinLevel) {
         WriteLine(msg, level);
         DumpToLog(BitConverter.ToString(dump).Replace('-', ' '));
     }
 }
Exemple #60
0
 public void Log(ELogType type, string message)
 {
     WriteEvent(new LogEventArgs(type, message));
 }