Esempio n. 1
0
 /// <summary>
 /// log the message according to loglevel set in config file
 /// </summary>
 /// <param name="logLevel">pass the loglevel of message</param>
 /// <param name="ex">Exception object need to pass for log</param>
 /// <param name="logMessage">"message to be logged"</param>
 /// <param name="messageFormat">"message with format"</param>
 /// <param name="obj">"array of object that to be used by message format"</param>
 public void LogInfo(LogLevelWrapper logLevel, Exception ex, string logMessage, string messageFormat = null, params object[] obj)
 {
     if (log != null)
     {
         logger(logLevel, ex, logMessage, messageFormat, obj);
     }
 }
Esempio n. 2
0
        /// <summary>
        /// private common function to log the message according to loglevel set in config file
        /// </summary>
        /// <param name="logLevel">pass the loglevel of message</param>
        /// <param name="ex">Exception object need to pass for log</param>
        /// <param name="logMessage">"message to be logged"</param>
        /// <param name="messageFormat">"message with format"</param>
        /// <param name="obj">"array of object that to be used by message format"</param>
        private void logger(LogLevelWrapper logLevel, Exception ex, string logMessage, string messageFormat = null, params object[] obj)
        {
            //if obj is null initilize with empty arry of object
            if (obj == null)
            {
                obj = new object[] { };
            }
            //verify log level
            switch (logLevel)
            {
            case LogLevelWrapper.ALL:
            case LogLevelWrapper.DEBUG:
                //verify if logger is configured to log the Debug level message
                if (log.IsDebugEnabled)
                {
                    //if message format is provided then log both messages
                    if (!string.IsNullOrEmpty(messageFormat))
                    {
                        log.Debug(logMessage, ex);
                        log.DebugFormat(messageFormat, obj);
                    }
                    //else log the message only
                    else
                    {
                        log.Debug(logMessage, ex);
                    }
                }
                break;

            case LogLevelWrapper.INFO:
                if (log.IsInfoEnabled)
                {
                    if (!string.IsNullOrEmpty(messageFormat))
                    {
                        log.Info(logMessage, ex);
                        log.InfoFormat(messageFormat, obj);
                    }
                    else
                    {
                        log.Info(logMessage, ex);
                    }
                }
                break;

            case LogLevelWrapper.WARN:
                if (log.IsWarnEnabled)
                {
                    if (!string.IsNullOrEmpty(messageFormat))
                    {
                        log.Warn(logMessage, ex);
                        log.WarnFormat(messageFormat, obj);
                    }
                    else
                    {
                        log.Warn(logMessage, ex);
                    }
                }
                break;

            case LogLevelWrapper.ERROR:

                if (log.IsErrorEnabled)
                {
                    if (!string.IsNullOrEmpty(messageFormat))
                    {
                        log.Error(logMessage, ex);
                        log.ErrorFormat(messageFormat, obj);
                    }
                    else
                    {
                        log.Error(logMessage, ex);
                    }
                }

                break;

            case LogLevelWrapper.FATAL:
                if (log.IsFatalEnabled)
                {
                    if (!string.IsNullOrEmpty(messageFormat))
                    {
                        log.Fatal(logMessage, ex);
                        log.FatalFormat(messageFormat, obj);
                    }
                    else
                    {
                        log.Fatal(logMessage, ex);
                    }
                }
                break;

            default:

                break;
            }
        }