FileLogImpl.cs 7.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218
  1. //using System;
  2. //using System.Collections.Generic;
  3. //using System.Text;
  4. //using System.Diagnostics;
  5. //using System.Collections;
  6. //using System.IO;
  7. //using COSXML.Utils;
  8. //using System.Threading;
  9. //namespace COSXML.Log
  10. //{
  11. // /// <summary>
  12. // /// 异步写入本地文件日志
  13. // /// 日志路径:当前应用工程的Log文件夹下
  14. // /// 后台写入:开启一个后台线程 logThread
  15. // /// 缓存区域:开辟一块临时日志缓存区域 logBuffer
  16. // /// 消息循环机制:循环获取->写入 handle -> looper
  17. // /// </summary>
  18. // public sealed class FileLogImpl : Log
  19. // {
  20. // private string logDir;
  21. // private const int LOG_BUFFER_SIZE = 32 * 1024; //32kb
  22. // private const int LOG_FILE_MAX_COUNTS = 30; // 30个文件数
  23. // private const int LOG_FILE_MAX_LENGTH = 3 * 1048576; // 文件最大为3M
  24. // private Queue<string> logFiles;
  25. // private List<string> buffer;
  26. // private int currentBufferSize;
  27. // private Handler handler;
  28. // public const byte MESSAGE_COMNE_IN = 0;
  29. // public const byte MESSAGE_FLUSH = 1;
  30. // public FileLogImpl(string logDir)
  31. // {
  32. // if (String.IsNullOrEmpty(logDir))
  33. // {
  34. // Trace.WriteLine("log dir = null");
  35. // }
  36. // else
  37. // {
  38. // this.logDir = logDir;
  39. // DirectoryInfo dirInfo = new DirectoryInfo(logDir);
  40. // if (!dirInfo.Exists) dirInfo.Create();
  41. // logFiles = new Queue<string>(30);
  42. // buffer = new List<string>(10);
  43. // currentBufferSize = 0;
  44. // handler = new Handler();
  45. // handler.OnHandleMessage = OnHandleMessage;
  46. // Thread logThread = new Thread(handler.InternalHandle) { Name = "LogThread", IsBackground = true};
  47. // logThread.Start();
  48. // }
  49. // }
  50. // private void OnHandleMessage(Message message)
  51. // {
  52. // Trace.WriteLine(String.Format("currentThread :name = {0} id = {1} isBackground = {2}", Thread.CurrentThread.Name, Thread.CurrentThread.ManagedThreadId,
  53. // Thread.CurrentThread.IsBackground));
  54. // switch (message.what)
  55. // {
  56. // case MESSAGE_COMNE_IN:
  57. // WriteLogToBuffer((string)message.obj);
  58. // break;
  59. // case MESSAGE_FLUSH:
  60. // WriteLogToFile();
  61. // break;
  62. // }
  63. // }
  64. // public void PrintLog(string logMessage)
  65. // {
  66. // if (handler == null) return;
  67. // Message message = new Message();
  68. // message.what = MESSAGE_COMNE_IN;
  69. // message.obj = logMessage;
  70. // handler.SendMessage(message);
  71. // }
  72. // private void WriteLogToBuffer(string message)
  73. // {
  74. // if (message != null)
  75. // {
  76. // buffer.Add(message);
  77. // currentBufferSize += message.Length;
  78. // if (currentBufferSize > LOG_BUFFER_SIZE)
  79. // {
  80. // handler.SendMessage(MESSAGE_FLUSH);
  81. // }
  82. // }
  83. // }
  84. // private string GetCurrentLogFilePath()
  85. // {
  86. // if (logFiles.Count == 0)
  87. // {
  88. // DirectoryInfo dirInfo = new DirectoryInfo(logDir);
  89. // FileInfo[] fileInfos = dirInfo.GetFiles();
  90. // Array.Sort(fileInfos, delegate(FileInfo f1, FileInfo f2)
  91. // {
  92. // long prefix1 = 0, prefix2 = 0;
  93. // long.TryParse(f1.Name.Split('.')[0], out prefix1);
  94. // long.TryParse(f2.Name.Split('.')[0], out prefix2);
  95. // if (prefix1 > prefix2) return 1;
  96. // if (prefix1 == prefix2) return 0;
  97. // if (prefix1 < prefix2) return -1;
  98. // return 0;
  99. // });
  100. // foreach (FileInfo fileInfo in fileInfos)
  101. // {
  102. // logFiles.Enqueue(fileInfo.FullName);
  103. // }
  104. // }
  105. // int count = logFiles.Count - LOG_FILE_MAX_COUNTS;
  106. // for (int i = 0; i < count; i++)
  107. // {
  108. // logFiles.Dequeue();
  109. // }
  110. // if (logFiles.Count > 0)
  111. // {
  112. // FileInfo lastFileInfo = new FileInfo(logFiles.ToArray()[logFiles.Count - 1]);
  113. // if (lastFileInfo.Length < LOG_FILE_MAX_LENGTH)
  114. // {
  115. // return lastFileInfo.FullName;
  116. // }
  117. // }
  118. // string logFileName = String.Format("{0}.log", TimeUtils.GetCurrentTime(TimeUnit.SECONDS));
  119. // string logFilePath = logDir + System.IO.Path.DirectorySeparatorChar + logFileName;
  120. // logFiles.Enqueue(logFilePath);
  121. // return logFilePath;
  122. // }
  123. // private void WriteLogToFile()
  124. // {
  125. // FileStream fileStream = null;
  126. // StreamWriter streamWriter = null;
  127. // try
  128. // {
  129. // string logFile = GetCurrentLogFilePath();
  130. // fileStream = new FileStream(logFile, FileMode.Append, FileAccess.Write);
  131. // streamWriter = new StreamWriter(fileStream);
  132. // foreach (string content in buffer)
  133. // {
  134. // streamWriter.Write(content);
  135. // }
  136. // streamWriter.Flush();
  137. // buffer.Clear();
  138. // currentBufferSize = 0;
  139. // }
  140. // catch (Exception)
  141. // {
  142. // //Trace.WriteLine(ex.StackTrace);
  143. // }
  144. // finally
  145. // {
  146. // if (streamWriter != null) streamWriter.Close();
  147. // //if (fileStream != null)
  148. // //{
  149. // // fileStream.Close();
  150. // //}
  151. // }
  152. // }
  153. // }
  154. // public class Handler
  155. // {
  156. // private Queue<Message> messageQueue = new Queue<Message>(20);
  157. // public void SendMessage(Message message)
  158. // {
  159. // messageQueue.Enqueue(message);
  160. // }
  161. // public void SendMessage(int what)
  162. // {
  163. // Message message = new Message();
  164. // message.what = what;
  165. // messageQueue.Enqueue(message);
  166. // }
  167. // public HandleMessage OnHandleMessage;
  168. // public void InternalHandle()
  169. // {
  170. // long start = TimeUtils.GetCurrentTime(TimeUnit.SECONDS);
  171. // while (true)
  172. // {
  173. // try
  174. // {
  175. // Message message = messageQueue.Dequeue();
  176. // OnHandleMessage(message);
  177. // }
  178. // catch (Exception)
  179. // {
  180. // //Trace.WriteLine(ex.StackTrace);
  181. // }
  182. // long end = TimeUtils.GetCurrentTime(TimeUnit.SECONDS);
  183. // if (end - start > 10)
  184. // {
  185. // start = end;
  186. // SendMessage(FileLogImpl.MESSAGE_FLUSH);
  187. // }
  188. // }
  189. // }
  190. // }
  191. // public delegate void HandleMessage(Message message);
  192. // public class Message
  193. // {
  194. // public int what;
  195. // public Object obj;
  196. // }
  197. //}