C# LogCategory类代码示例

		///<summary>
		/// Logs the message to the configured loLog4Netgger with the 
		/// appropriate <see cref="LogCategory"/>
		///</summary>
		///<param name="message"></param>
		///<param name="logCategory"></param>
		public void Log(string message, LogCategory logCategory)
		{
			if (!IsLogging(logCategory)) return;
			switch (logCategory)
			{
				case LogCategory.Fatal:
					_log.Fatal(message);
					break;
				case LogCategory.Exception:
					_log.Error(message);
					break;
				case LogCategory.Debug:
					_log.Debug(message);
					break;
				case LogCategory.Warn:
					_log.Warn(message);
					break;
                case LogCategory.Error:
                    _log.Error(message);
                    break;
				default:
					_log.Info(message);
					break;
			}
		}

 public void Log(LogCategory category, string text, params object[] parameters)
 {
     if ((EnabledCategories & category) != 0)
     {
         Stream.WriteLine(text, parameters);
     }
 }

        /// <summary>
        /// This method is used to Log any message in the Application.
        /// </summary>
        /// <param name="eventId">Id of the event. Based on which the message will be retrieved from resource file.</param>
        /// <param name="ex">Exception object that needs to be logged in.</param>
        /// <param name="message">Some extra information / message that user will like to log.</param>
        /// <param name="category">A category which will determine where the message will get logged.</param>
        /// <param name="severity">Severity of the message. (Information / Warning / Error)</param>
        public static void LogException(int eventId, Exception ex, string message, LogCategory category, TraceEventType severity)
        {
            try
            {
                var categories = new List<LogCategory> { category };

                var extendedInformation = new Dictionary<string, object> { { "Exception", ex } };

                if (string.IsNullOrEmpty(message))
                {
                    message = ex.Message + " - Stack Trace : " + ex.StackTrace;
                }
                else
                {
                    message = message + " - " + ex.Message + " - Stack Trace : " + ex.StackTrace;
                    if (message.Length > MAX_EVENTLOG_STRING_LENGTH)
                        message = message.Substring(0, MAX_EVENTLOG_STRING_LENGTH);
                }

                WriteLogEntry(eventId, message, categories, severity, extendedInformation);
            }
            catch (Exception)
            {
            }
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="LogEntry"/> class by specifying the category and the detailed information to write.
 /// </summary>
 /// <param name="category">
 /// The log category of this instance.
 /// </param>
 /// <param name="data">
 /// The data containing the detailed information to write to log.
 /// </param>
 public LogEntry(LogCategory category, object data)
 {
     Id = Guid.NewGuid();
     Category = category;
     Created = DateTime.Now;
     Data = data;
 }

 public void Log(string message, LogCategory logCategory)
 {
     if (!IsLogging(logCategory)) return;
     Console.Out.WriteLine("{0} {1} {2} {3} {4}", DateTime.Now.ToShortDateString(),
                           DateTime.Now.ToShortTimeString(), _contextName,
                           Enum.GetName(typeof (LogCategory), logCategory), message);
 }

 public static void SetTraceLevel(LogCategory category, SourceLevels sourceLevel)
 {
     var sourceSwitch = new SourceSwitch(string.Format(CultureInfo.InvariantCulture, "MigSharp.{0}.Switch", category))
     {
         Level = sourceLevel
     };
     Sources[category].Switch = sourceSwitch;
 }

 /// <summary>
 /// Writes a log entry via the logger from <see cref="Logger.Current" />.
 /// </summary>
 /// <param name="msg">The message to write.</param>
 /// <param name="category">The category.</param>
 /// <param name="prio">The priority.</param>
 /// <param name="tag">The optional tag.</param>
 /// <returns>Message was written or not.</returns>
 public static bool Log(object msg,
                        LogCategory category = LogCategory.Info, LogPriority prio = LogPriority.None,
                        string tag = null)
 {
     return Current.Log(msg: msg,
                        category: category, prio: prio,
                        tag: tag);
 }

 public static void Log(this IEnumerable<Logging.ILog> logs, LogCategory category, string message)
 {
     if (null == logs)
         return;
     foreach (var l in logs)
         if(null != l)
             l.Log(category, message);
 }

 public override void Log(LogCategory category, string message)
 {
     if (this.Stack.Count == 0)
         return;
     var ts = this.Stack.Peek();
     if(null != ts)
         ts.Log(category, message);
 }

 public override void Log(LogCategory category, string message)
 {
     System.Diagnostics.Debug.WriteLine
         (
         "{0}ms\t{1}",
         this.Elapsed.TotalMilliseconds,
         message
         );
 }

        public static void LogEntryAsync(string message, LogSeverity logSeverity, LogCategory logCategory)
        {
            Task.Factory.StartNew(() => Logger.Write(new LogEntry
            {
	            Title = logCategory.ToString(),
	            Message = message,
	            Categories = new List<string> { logCategory.ToString() },
	            Severity = GetSeverity(logSeverity)
            }));
        }

        /// <summary>
        /// Async operation of <see cref="LoggerBase.Log(object, LogCategory, LogPriority, string)" /> method.
        /// </summary>
        /// <param name="msg">The message.</param>
        /// <param name="category">The category.</param>
        /// <param name="prio">The priority.</param>
        /// <param name="tag">The tag.</param>
        /// <returns>The started task.</returns>
        public Task<bool> LogAsync(object msg,
                                   LogCategory category = LogCategory.Info, LogPriority prio = LogPriority.None,
                                   string tag = null)
        {
            var logMsg = CreateMessage(msg: msg,
                                       category: category, prio: prio,
                                       tag: tag);

            return LogAsync(logMsg: logMsg);
        }

 public static void LogEntry(string message, LogSeverity logSeverity, LogCategory logCategory)
 {
     Logger.Write(new LogEntry
     {
         Title = logCategory.ToString(),
         Message = message,
         Categories = new List<string> { logCategory.ToString() },
         Severity = GetSeverity(logSeverity)
     });
 }

 public static LogMessage Create(LogCategory logCategory, LogSeverity logSeverity, string description)
 {
     return new LogMessage
         {
             Category = logCategory,
             Severity = logSeverity,
             Description = description,
             CreatedBy = "System",
             CreatedDate = DateTime.Now
         };
 }

        //[Conditional("TRACE")]
        public static void Trace(LogCategory category, string message, params object[] args)
        {
            //Queue.Queue(delegate
            //{
                ThreadContext.Properties["Category"] = category;
                string messageToLog = string.Format(message, args);

                ConsoleLog(ConsoleColor.Gray, message, args);
                _logger.Logger.Log(typeof(Log), TRACELevelTRACE, messageToLog, null);
            //});
        }