// Help methods that use our FileSystem abstraction
        public override void AppendLog(String message, LogMessageType messageType)
        {
            string textEntry = string.Format("{0:MM-dd-yyyy HH:mm:ss:ffff} :{1}: [{2}] {3}", DateTime.Now, System.Threading.Thread.CurrentThread.ManagedThreadId, messageType.ToString(), message);

            switch (messageType)
            {
                case LogMessageType.Info:
                    Android.Util.Log.Info(TAG, message);
                    break;
                case LogMessageType.Warn:
                    Android.Util.Log.Debug(TAG, message);
                    break;
                case LogMessageType.Debug:
                    Android.Util.Log.Debug(TAG, message);
                    break;
                case LogMessageType.Error:
                    Android.Util.Log.Error(TAG, message);
                    break;
                case LogMessageType.Fatal:
                    Android.Util.Log.Wtf(TAG, message);
                    break;
                case LogMessageType.Metric:
                    Android.Util.Log.Debug( TAG_METRIC, message );
                    break;
                default:
                    break;
            }

            AppendText(LogFileName, textEntry);
        }

		/// <summary>
		/// Writes a single message to the output.
		/// </summary>
		/// <param name="source">The <see cref="Log"/> from which the message originates.</param>
		/// <param name="type">The type of the log message.</param>
		/// <param name="msg">The message to write.</param>
		/// <param name="context">The context in which this log was written. Usually the primary object the log entry is associated with.</param>
		public virtual void Write(Log source, LogMessageType type, string msg, object context)
		{
			int indent = source.Indent;
			string prefix = source.Prefix ?? "";
			string[] lines = msg.Split(new[] { '\n', '\r', '\0' }, StringSplitOptions.RemoveEmptyEntries);
			for (int i = 0; i < lines.Length; i++)
			{
				if (i == 0)
				{
					switch (type)
					{
						case LogMessageType.Message:
							lines[i] = prefix + "Msg: " + new string(' ', indent * 2) + lines[i];
							break;
						case LogMessageType.Warning:
							lines[i] = prefix + "Wrn: " + new string(' ', indent * 2) + lines[i];
							break;
						case LogMessageType.Error:
							lines[i] = prefix + "ERR: " + new string(' ', indent * 2) + lines[i];
							break;
					}
				}
				else
				{
					lines[i] = new string(' ', prefix.Length + 5 + indent * 2) + lines[i];
				}

				this.WriteLine(source, type, lines[i], context);
			}
		}

        /// <summary>
        /// Writes a single message to the output.
        /// </summary>
        /// <param name="source">The <see cref="Log"/> from which the message originates.</param>
        /// <param name="type">The type of the log message.</param>
        /// <param name="msg">The message to write.</param>
        /// <param name="context">The context in which this log was written. Usually the primary object the log entry is associated with.</param>
        public virtual void Write(Log source, LogMessageType type, string msg, object context)
        {
            int indent = source.Indent;
            string[] lines = msg.Split(new[] { '\n', '\r' }, StringSplitOptions.RemoveEmptyEntries);
            for (int i = 0; i < lines.Length; i++)
            {
                if (i == 0)
                {
                    switch (type)
                    {
                        case LogMessageType.Message:
                            lines[i] = source.Prefix + "Info:    " + new string(' ', indent * 4) + lines[i];
                            break;
                        case LogMessageType.Warning:
                            lines[i] = source.Prefix + "Warning: " + new string(' ', indent * 4) + lines[i];
                            break;
                        case LogMessageType.Error:
                            lines[i] = source.Prefix + "ERROR:   " + new string(' ', indent * 4) + lines[i];
                            break;
                    }
                }
                else
                {
                    lines[i] = source.Prefix + "         " + new string(' ', indent * 4) + lines[i];
                }

                this.writer.WriteLine(lines[i]);
            }
        }

 public LogMessage(String message, LogMessageType type, LogMessageSeverity severity, Exception exception)
 {
     Message = message;
     Type = type;
     Severity = severity;
     Exception = exception;
 }

 /// <summary>
 /// Write Log By MessageType
 /// </summary>
 /// <param name="message">Message</param>
 /// <param name="messageType">MessageType</param>
 /// <param name="ex">Exception Object</param>
 /// <param name="type">Log Source Type</param>
 private static void DoLog(string message, LogMessageType messageType, Exception ex, Type type)
 {
     string stackTrace = string.Empty;
     if (ex != null)
     {
         stackTrace = ex.StackTrace;
     }
     _mLog = LogManager.GetLogger(type);
     switch (messageType)
     {
         case LogMessageType.Debug:
             //AppLog._mLog.Debug(message + " ExceptionStackTrace:" + stackTrace, ex);//Edit by Gerry
             AppLog._mLog.Debug(message + stackTrace, ex);
             break;
         case LogMessageType.Info:
             AppLog._mLog.Info(message + stackTrace, ex);
             break;
         case LogMessageType.Warn:
             AppLog._mLog.Warn(message + stackTrace, ex);
             break;
         case LogMessageType.Error:
             AppLog._mLog.Error(message + stackTrace, ex);
             break;
         case LogMessageType.Fatal:
             AppLog._mLog.Fatal(message + stackTrace, ex);
             break;
     }
 }

		void Colorize ( LogMessageType eventType )
		{
			switch (eventType) {
				case LogMessageType.Debug :
					Console.ForegroundColor	=	ConsoleColor.DarkGreen;
					Console.BackgroundColor	=	ConsoleColor.Black;
				break;
				case LogMessageType.Verbose :
					Console.ForegroundColor	=	ConsoleColor.DarkGray;
					Console.BackgroundColor	=	ConsoleColor.Black;
				break;
				case LogMessageType.Information :
					Console.ForegroundColor	=	ConsoleColor.Gray;
					Console.BackgroundColor	=	ConsoleColor.Black;
				break;
				case LogMessageType.Warning :
					Console.ForegroundColor	=	ConsoleColor.Yellow;
					Console.BackgroundColor	=	ConsoleColor.Black;
				break;
				case LogMessageType.Error :
					Console.ForegroundColor	=	ConsoleColor.Red;
					Console.BackgroundColor	=	ConsoleColor.Black;
				break;
				case LogMessageType.Fatal :
					Console.ForegroundColor	=	ConsoleColor.Yellow;
					Console.BackgroundColor	=	ConsoleColor.Red;
				break;
			}
		}

 public LogMessage(string text, DateTime timestamp, string sourceInfo, LogMessageType type)
 {
     this.text = text;
     this.timestamp = timestamp;
     this.sourceInfo = sourceInfo;
     this.type = type;
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="LogMessage"/> class.
 /// </summary>
 /// <param name="content">
 /// The content.
 /// </param>
 /// <param name="messageType">
 /// The message type.
 /// </param>
 /// <param name="logLevel">
 /// The log level.
 /// </param>
 /// <param name="messageIndex">
 /// The message Index.
 /// </param>
 public LogMessage(string content, LogMessageType messageType, LogLevel logLevel, long messageIndex)
 {
     this.Content = content;
     this.MessageType = messageType;
     this.LogLevel = logLevel;
     this.MessageIndex = messageIndex;
 }

 public void WriteLineTest1()
 {
     LogMessageType messageFlag = new LogMessageType(); // TODO: 初始化为适当的值
     string strFormat = string.Empty; // TODO: 初始化为适当的值
     object[] arg = null; // TODO: 初始化为适当的值
     LOGs.WriteLine( messageFlag, strFormat, arg );
     Assert.Inconclusive( "无法验证不返回值的方法。" );
 }

		TextWriter GetWriter ( LogMessageType eventType )
		{
			if ( eventType==LogMessageType.Error || eventType==LogMessageType.Warning || eventType==LogMessageType.Fatal ) {
				return Console.Error;
			} else {
				return Console.Out;
			}
		}

 /// <summary>
 /// Initializes a new instance of the <see cref="AssetLogMessage" /> class.
 /// </summary>
 /// <param name="package">The package.</param>
 /// <param name="assetReference">The asset reference.</param>
 /// <param name="type">The type.</param>
 /// <param name="messageCode">The message code.</param>
 /// <param name="arguments">The arguments.</param>
 /// <exception cref="System.ArgumentNullException">asset</exception>
 public AssetLogMessage(Package package, IReference assetReference, LogMessageType type, string text)
 {
     this.package = package;
     AssetReference = assetReference;
     Type = type;
     Related = new List<IReference>();
     Text = text;
 }

 public override void WriteMessage(string message, LogMessageType type, Exception exception)
 {
 	if (type == LogMessageType.Error)
 		System.Threading.Interlocked.Increment(ref ErrorCount);
 	else if (type == LogMessageType.Warning)
 		System.Threading.Interlocked.Increment(ref WarningCount);
     base.WriteMessage(this.Backupset + ", " + message, type, exception);
 }

        // Help methods that use our FileSystem abstraction
        public override void AppendLog(String message, LogMessageType messageType)
        {
            string textEntry = string.Format("{0:MM-dd-yyyy HH:mm:ss:ffff} :{1}: [{2}] {3}", DateTime.Now, System.Threading.Thread.CurrentThread.ManagedThreadId, messageType.ToString(), message);

            Console.WriteLine(textEntry);

            AppendText(LogFileName, textEntry);
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="LogMessage" /> class.
 /// </summary>
 /// <param name="module">The module.</param>
 /// <param name="type">The type.</param>
 /// <param name="text">The text.</param>
 /// <param name="exception">The exception.</param>
 /// <param name="callerInfo">The caller info.</param>
 public LogMessage(string module, LogMessageType type, string text, Exception exception, CallerInfo callerInfo)
 {
     Module = module;
     Type = type;
     Text = text;
     Exception = exception;
     CallerInfo = callerInfo;
 }

        /// <summary>
        /// Activates the log for loggers that match a regex pattern on the module name.
        /// </summary>
        /// <param name="regexPatternModule">The regex pattern to match a module name.</param>
        /// <param name="minimumLevel">The minimum level.</param>
        /// <param name="maximumLevel">The maximum level.</param>
        /// <param name="enabledFlag">if set to <c>true</c> enaable the log, else disable.</param>
        /// <exception cref="ArgumentNullException">If regexPatternModule is null</exception>
        public static void ActivateLog(string regexPatternModule, LogMessageType minimumLevel, LogMessageType maximumLevel = LogMessageType.Fatal, bool enabledFlag = true)
        {
            if (regexPatternModule == null)
                throw new ArgumentNullException("regexPatternModule");

            var regex = new Regex(regexPatternModule);
            ActivateLog(regex, minimumLevel, maximumLevel);
        }

 /// <summary>
 /// 
 /// </summary>
 /// <param name="messageFlag"></param>
 /// <param name="strFormat"></param>
 /// <param name="parameter"></param>
 public LogInfo(LogMessageType messageFlag, string strFormat, object[] parameter = null)
 {
     m_messageFlag = messageFlag;
     format = strFormat;
     _parameter = parameter;
     outStr = null;
     time = DateTime.Now;
 }

        public LogMessageEventArgs(LogMessageType logMessageType, string message)
        {
            if (message == null)
                throw new ArgumentNullException("message");

            LogMessageType = logMessageType;
            Message = message;
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="SerializableLogMessage"/> class using the given parameters to set its properties.
 /// </summary>
 /// <param name="module">The module name.</param>
 /// <param name="type">The type.</param>
 /// <param name="text">The text.</param>
 /// <param name="exceptionInfo">The exception information. This parameter can be null.</param>
 public SerializableLogMessage(string module, LogMessageType type, string text, ExceptionInfo exceptionInfo = null)
 {
     if (module == null) throw new ArgumentNullException("module");
     if (text == null) throw new ArgumentNullException("text");
     Module = module;
     Type = type;
     Text = text;
     ExceptionInfo = exceptionInfo;
 }

 /// <summary>
 /// The function called when a message is logged
 /// </summary>
 /// <param name="message">The message logged</param>
 /// <param name="type">The type of message logged</param>
 /// <param name="exception">An exception, may be null</param>
 public virtual void WriteMessage(string message, LogMessageType type, Exception exception)
 {
     m_stream.WriteLine("{0:u} - {1}: {2}", DateTime.Now, type, message);
     if (exception != null)
     {
         m_stream.WriteLine(exception.ToString());
         m_stream.WriteLine();
     }
 }

			public LogEntry(Log source, LogMessageType type, string msg)
			{
				this.source = source;
				this.type = type;
				this.msg = msg;
				this.indent = source.Indent;
				this.timestamp = DateTime.Now;
				this.frameIndex = Time.FrameCount;
			}