kreta/Framework/Logging/ConsoleLogWriter.cs

using System;
using System.Diagnostics;

namespace Kreta.Framework.Logging
{
    /// <summary>
    /// Konzol naplóvezető.
    /// </summary>
    public sealed class ConsoleLogWriter : LogWriterBase
    {
        const ConsoleColor _defaultConsoleColor = ConsoleColor.Gray;
        const ConsoleColor _entrySeparatorColor = ConsoleColor.Cyan;
        const string _entrySeparator = ">> ";

        static readonly object _syncRoot = new object();

        static ConsoleLogWriter()
        {
            SetDebug();
        }

        [Conditional("DEBUG")]
        static void SetDebug()
        {
            DebugEnabled = true;
        }

        /// <summary>
        /// Visszaadja a naplózási szinthez tartozó színt.
        /// </summary>
        /// <param name="level">A naplózási szint</param>
        /// <returns></returns>
        static ConsoleColor GetConsoleForegroundColor(LogLevel level)
        {
            switch (level)
            {
                case LogLevel.DEBUG:
                    {
                        return ConsoleColor.Gray;
                    }
                case LogLevel.INFO:
                    {
                        return ConsoleColor.Green;
                    }
                case LogLevel.WARNING:
                    {
                        return ConsoleColor.Yellow;
                    }
                case LogLevel.ERROR:
                    {
                        return ConsoleColor.Red;
                    }
                case LogLevel.FATAL:
                    {
                        return ConsoleColor.Magenta;
                    }
                default:
                    {
                        return _defaultConsoleColor;
                    }
            }
        }

        /// <summary>
        /// Konzolra és a Debug-ra írja a megadott szöveget. Sortöréssel.
        /// </summary>
        /// <param name="messageText">A kiírandó szöveg</param>
        /// <param name="level">A naplózási szint</param>
        public static void WriteLine(string messageText, LogLevel level)
        {
            WriteLineToDebug(messageText, level);
            WriteLineToConsole(messageText, level, false);
        }

        /// <summary>
        /// Konzolra és a Debug-ra írja a megadott szöveget.
        /// </summary>
        /// <param name="messageText">A kiírandó szöveg</param>
        /// <param name="level">A naplózási szint</param>
        public static void Write(string messageText, LogLevel level)
        {
            WriteToDebug(messageText, level);
            WriteToConsole(messageText, level);
        }

        /// <summary>
        /// Konzolra ír egy üzenetet. Sortöréssel
        /// </summary>
        /// <param name="messageText">Az üzenet szövege</param>
        public static void WriteLine(string messageText)
        {
            WriteLine(messageText, LogLevel.UNKNOWN);
        }

        /// <summary>
        /// Konzolra ír egy üzenetet.
        /// </summary>
        /// <param name="messageText">Az üzenet szövege</param>
        public static void Write(string messageText)
        {
            Write(messageText, LogLevel.UNKNOWN);
        }

        /// <summary>
        /// Naplóba vezeti az üzenetet.
        /// </summary>
        /// <param name="message">A naplóba vezetendő üzenet</param>
        protected override Guid? DoLog(ILogMessage message)
        {
            string messagetext = LogUtil.FormatMessageCompact(message);
            WriteLineToDebug(messagetext, message.Level);
            WriteLineToConsole(messagetext, message.Level, true);
            return null;
        }

        protected override void DoLog(ILogMessage message, Guid logId)
        {
            DoLog(message);
        }

        #region inneroperations

        static void WriteToConsole(string messagetext, LogLevel level)
        {
            if (!ConsoleEnabled)
            {
                return;
            }
            lock (_syncRoot)
            {
                Console.ForegroundColor = GetConsoleForegroundColor(level);
                Console.WriteLine(messagetext);
                Console.ForegroundColor = _defaultConsoleColor;
            }
        }

        static void WriteLineToConsole(string messagetext, LogLevel level, bool islog)
        {
            if (!ConsoleEnabled)
            {
                return;
            }
            lock (_syncRoot)
            {
                if (islog)
                {
                    Console.ForegroundColor = _entrySeparatorColor;
                    Console.Write(_entrySeparator);
                }
                Console.ForegroundColor = GetConsoleForegroundColor(level);
                Console.WriteLine(messagetext);
                Console.ForegroundColor = _defaultConsoleColor;
            }
        }

        static void WriteToDebug(string messagetext, LogLevel level)
        {
            if (!DebugEnabled)
            {
                return;
            }
            switch (level)
            {
                case LogLevel.DEBUG:
                    Debug.Write(messagetext);
                    break;
                case LogLevel.ERROR:
                case LogLevel.FATAL:
                    Trace.TraceError(messagetext);
                    break;
                case LogLevel.WARNING:
                    Trace.TraceWarning(messagetext);
                    break;
                default:
                    Trace.TraceInformation(messagetext);
                    break;
            }
        }

        static void WriteLineToDebug(string messagetext, LogLevel level)
        {
            if (!DebugEnabled)
            {
                return;
            }
            switch (level)
            {
                case LogLevel.DEBUG:
                    Debug.WriteLine(messagetext);
                    break;
                case LogLevel.ERROR:
                case LogLevel.FATAL:
                    Trace.TraceError(messagetext);
                    break;
                case LogLevel.WARNING:
                    Trace.TraceWarning(messagetext);
                    break;
                default:
                    Trace.TraceInformation(messagetext);
                    break;
            }
        }

        #endregion

        /// <summary>
        /// Engedélyezi vagy tiltja a konzolra való naplózást. Alapértelmezésben tiltott.
        /// </summary>
        public static bool ConsoleEnabled { get; set; }

        /// <summary>
        /// Engedélyezi vagy tiltja a debug-ra való naplózást. Alapértelmezésben tiltott.
        /// </summary>
        public static bool DebugEnabled { get; set; }
    }
}