[Original] A dynamic configuration log module

Usage: var StringsLogger: TStringsLogger; begin // log StringsLogger: = TStringsLogger.Create (); StringsLogger.MaxLogCount: = 20; StringsLogger.Strings: = txtLog.Lines; // a memo of Lines Log: = TMultiThreadLog.Create (StringsLogger , Lt_debug); // Multi-thread, use queue, efficiency estimate is very low // log: = tsingLethreadLog.create (stringslogger, lt_debug); // single-thread end; the following is unitlog.pas // ====== ============================================================================================================================================================================================================= ===================== Unit unitlog;

Interfaceuses Windows, Messages, Sysutils, Variants, Classes, Graphics, Controls, Forms, Dialogs, stdctrls

Type // log is divided into five levels as follows: ELogType = (LT_FATAL, LT_ERROR, LT_WARN, LT_INFO, LT_DEBUG);

// log information class Tlogmsg = class logtype: ELOGTYPE; TIME: TDATETIME; MSG: String; End; // LOG write module's basic class for writing logs, behind TStringsLogger is inheriting, or you can implement each The form of writing modules such as TFileLogger, TSTREAMLogger, and the like can achieve the purpose of arbitrary orientation LOG output. Tloggerbase = class procedure open (); virtual; absgract; procedure close (); virtual; abstract; procedure write (logmsg: tlogmsg); virtual;

// Log module base class, is behind the single-threaded and multi-threaded Log Log inherit it TLogBase = class protected FLogType: ELogType; FLogger: TLoggerBase; constructor Create (); overload; public property LogType: ELogType read FLogType write FLogType; property Logger: TLoggerBase read fLogger write fLogger; constructor Create (logger: TLoggerBase; logType: ELogType = LT_INFO); overload; destructor Destroy (); override; public procedure fatal (msg: string); procedure error (msg: string); procedure warn (MSG: String); Procedure INFO; Procedure Debug (MSG: String); Procedure log (logmsg: tlogmsg); virtual; abstract; end; // Based on TStrings Tstringslogger = Class ( TLoggerBase) protected FStrings: TStrings; FMaxLogCount: integer; public property Strings: TStrings read FStrings write FStrings; property MaxLogCount: integer read FMaxLogCount write FMaxLogCount; procedure open (); override; procedure close (); override; procedure write (logMsg: TLogMsg Override;

// Single thread log tingsingLethreadLog = Class (TLOGBASE) Public Procedure log (logmsg: tlogmsg); OVERRIDE;

TMultiThreadLog = class; // Log multithreaded thread class TMsgThread = class (TThread) protected MsgList: TThreadList; public MultiThreadLog: TMultiThreadLog; constructor Create (CreateSuspended: Boolean); destructor Destroy (); override; procedure Execute; override; procedure HandleInput Procedure pushmsg (logmsg: tlogmsg); function popmsg (): TLOGMSG; END; // Multithreaded log, use TTHREADLIST to use TTHREADLIST to be a queue of information, output one at a fixed time, realize clumsy, estimated efficiency is not high TMULTITHREADLOG = Class (TLogBase) protected MsgThread: TMsgThread; public constructor Create (logger: TLoggerBase; logType: ELogType = LT_INFO); overload; procedure log (logMsg: TLogMsg); override; procedure logOne (logMsg: TLogMsg); end; function getLogTypeString (logType: ELogType): String; Var log: Tlogbase; // Global variable, just create an object. IMPLEMENTATION

{Public functions} function getLogTypeString (logType: ELogType): string; begin case logType of LT_FATAL: result: = 'Fatal'; LT_ERROR: result: = 'Error'; LT_WARN: result: = 'Warn'; LT_INFO: result: = 'Info'; LT_Debug: Result: = 'debug'; end;

{TLOGBASE}

Constructor Tlogbase.create ();

CONSTRUCTOR TLOGBASE.CREATE (LogTYPE: ELOGTYPE = LT_INFO); Begin FlogType: = LogType; Flogger: = Logger; FLOGGER.Open ();

DEStructor Tlogbase.Destroy; begin flogger.close (); inherited;

procedure TLogBase.debug (msg: string); var logMsg: TLogMsg; begin if FLogType> = LT_DEBUG then begin logMsg: = TLogMsg.Create; logMsg.LogType: = LT_DEBUG; logMsg.time: = Now (); logMsg.Msg: = MSG; log (logmsg); end; end;

procedure TLogBase.info (msg: string); var logMsg: TLogMsg; begin if FLogType> = LT_INFO then begin logMsg: = TLogMsg.Create; logMsg.LogType: = LT_INFO; logMsg.time: = Now (); logMsg.Msg: = msg; log (logMsg); end; end; procedure TLogBase.warn (msg: string); var logMsg: TLogMsg; begin if FLogType> = LT_WARN then begin logMsg: = TLogMsg.Create; logMsg.LogType: = LT_WARN; logMsg . Time: = now (); logmsg.msg: = msg; log (logmsg); end;

procedure TLogBase.error (msg: string); var logMsg: TLogMsg; begin if FLogType> = LT_ERROR then begin logMsg: = TLogMsg.Create; logMsg.LogType: = LT_ERROR; logMsg.time: = Now (); logMsg.Msg: = MSG; log (logmsg); end; end;

procedure TLogBase.fatal (msg: string); var logMsg: TLogMsg; begin if FLogType> = LT_FATAL then begin logMsg: = TLogMsg.Create; logMsg.LogType: = LT_FATAL; logMsg.time: = Now (); logMsg.Msg: = MSG; log (logmsg); end; end;

{TsingLethreadLog}

Procedure tsingLethreadlog.log (logmsg: tlogmsg); begin flogger.write (logmsg); logmsg.destroy;

{TMULTITHREADLOG}

constructor TMultiThreadLog.Create (logger: TLoggerBase; logType: ELogType); begin inherited Create (logger, logType); MsgThread: = TMsgThread.Create (true); MsgThread.MultiThreadLog: = self; MsgThread.FreeOnTerminate: = True; MsgThread.Resume ;

Procedure Tmultithreadlog.log (logmsg: tlogmsg); begin msgthread.pushmsg (logmsg);

Procedure Tmultithreadlog.logone (Logmsg: Tlogmsg); Begin Flogger.write (LogMSG);

{TMSGTHREAD}

constructor TMsgThread.Create (CreateSuspended: Boolean); begin inherited Create (CreateSuspended); MsgList: = TThreadList.Create; end; destructor TMsgThread.Destroy; begin MsgList.Destroy; inherited; end;

PROCEDURE TMSGTHREAD.EXECUTE; Begin While NOT TERMINATED DO BEGIN SYNCHRONIZE (HANDLEINPUT); SLEEP (10); end;

Procedure; ,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,

Function TMSGTHREAD.POPMSG: TLOGMSG; VAR List: TList; begin list: = msglist.locklist; if list.count <> 0 The begin result: = list.first; list.delete (0); Else Begin Result: = NIL ; End; msglist.unlocklist;

Procedure TMSGTHREAD.PUSHMSG (logmsg: tlogmsg); begin msglist.add (logmsg);

{TSTRINGSLOGGER} processure tstringslogger.open;

PROCEDURE TSTRINGSLOGGGGER.CLOSE;

procedure TStringsLogger.write (logMsg: TLogMsg); begin inherited; if FStrings.Count> = FMaxLogCount then FStrings.Delete (0); FStrings.Add ( '[' DateTimeToStr (logMsg.time) '] - [' getLogTypeString (logmsg.logtype) ']' logmsg.msg);

End.