First, start with the overall architecture:

 

- Old component features:

* Multithread queues are used, and mutex variables are used to control the writing of text by threads.

* Controlling the contention for resources through single-case locking

* Threads are randomly selected to be locked, and the log written may not be in the right order of time.

* A thread operates on text once, and switches operate on one thread, writing only one variable at a time.

 

- Advantages:

* Multi-threaded operation, surface improves operation efficiency

* Single lock to ensure uniqueness

 

- Disadvantages:

* Under performance, overoperation of io results in severe performance redundancy

* Write only one at a time

 

- Improvement

* Use producer-consumer mode, operate separately, and limit the number of threads

* Use stack queue, first in first out, ensure log order

* Single IO variable, batch write operation

 

Revamping results:

using System;
using System.Collections;
using System.IO;
using System.Text;
using System.Threading;
using System.Windows.Threading;

namespace Helper
{
    public static class LogHelper
    {
        private static readonly Queue LogQueue = new Queue();

        private static bool _isStreamClose = true;

        private static bool _isThreadBegin = false;

        private static StreamWriter _fileStreamWriter;

        private static readonly string fileName =@"BugLog.txt";

        static int _intervalTime = 10000;// 10s

        static System.Timers.Timer _timer = new System.Timers.Timer(_intervalTime);

        /// <summary>
        /// Add a log queue
        /// </summary>
        /// <param name="message"></param>
        public static void AddLog(string message)
        {
            string logContent = $"[{DateTime.Now:yyyy-MM-dd hh:mm:ss}] =>{message}";
            LogQueue.Enqueue(logContent);
            if (!_isThreadBegin)
            {
                BeginThread();
            }
        }

        public static void AddLog(Exception ex)
        {
            var logContent = $"[{DateTime.Now:yyyy-MM-dd hh:mm:ss}]The error occurred in:{ex.Source}，\r\n Contents:{ex.Message}";
            logContent += $"\r\n  Track:{ex.StackTrace}";
            LogQueue.Enqueue(logContent);
            if (!_isThreadBegin)
            {
                BeginThread();
            }
        }

        /// <summary>
        /// Read a piece of data from the log queue
        /// </summary>
        /// <returns></returns>
        private static object GetLog()
        {
            return LogQueue.Dequeue();
        }

        /// <summary>
        /// Open Timing Query Thread
        /// </summary>
        public static void BeginThread()
        {
            _isThreadBegin = true;

            //instantiation Timer Class, set the interval time to 10000 milliseconds;     

            _timer.Interval = _intervalTime;

            _timer.Elapsed += SetLog;

            //Execute the event at the time of arrival;   

            _timer.AutoReset = true;

            //Settings are executed once( false)It's still going on.(true)；     

            _timer.Enabled = true;
        }


        /// <summary>
        /// Write to the log
        /// </summary>
        private static void SetLog(object source, System.Timers.ElapsedEventArgs e)
        {
            if (LogQueue.Count == 0)
            {
                if (_isStreamClose) return;
                _fileStreamWriter.Flush();
                _fileStreamWriter.Close();
                _isStreamClose = true;
                return;
            }
            if (_isStreamClose)
            {
                Isexist();
                string errLogFilePath = Environment.CurrentDirectory + @"\Log\" + fileName.Trim();
                if (!File.Exists(errLogFilePath))
                {
                    FileStream fs1 = new FileStream(errLogFilePath, FileMode.Create, FileAccess.Write);
                    _fileStreamWriter = new StreamWriter(fs1);
                }
                else
                {
                    _fileStreamWriter = new StreamWriter(errLogFilePath, true);
                }
                _isStreamClose = false;
            }

            var strLog = new StringBuilder();

            var onceTime = 50;

            var lineNum = LogQueue.Count > onceTime ? onceTime : LogQueue.Count;

            for (var i = 0; i < lineNum; i++)
            {
                strLog.AppendLine(GetLog().ToString());
            }

            _fileStreamWriter.WriteLine(strLog.ToString());

        }

        /// <summary>
        /// Determine whether a log file exists
        /// </summary>
        private static void Isexist()
        {
            string path = Environment.CurrentDirectory + @"\Log\";
            if (!File.Exists(path))
            {
                Directory.CreateDirectory(path);
            }
        }
    }
}