Windows平台下程序日志的设计和实现（下：代码）

1、CConfiguration.cs

using System;
using System.Collections.Specialized;
using System.Xml;
using System.Configuration;

namespace com.lenovo.zhangyuk.logger
{
/// <summary>
/// CConfiguration 的摘要说明。
/// </summary>
public class CConfiguration
{
// 程序全局配置（配置文件相应内容在内存中的映射）
private static NameValueCollection _configration = new NameValueCollection();

private CConfiguration()
{
}

/// <summary>
/// 取配置项
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public static string getConfiguration( string key )
{
// 如果第一次取配置项，那么将所有配置项从文件读入内存，否则从内存中取出。
if( _configration.Count==0 )
{
_configration = ConfigurationSettings.AppSettings;
}

return (null != _configration[key]) ? _configration[key].ToString().Trim() : "";
}
}
}

2、ILogger.cs

using System;
using System.Diagnostics;

namespace com.lenovo.zhangyuk.logger
{
/// <summary>
/// 日志输出级别
/// </summary>
public enum enumLevel
{
DEBUG,
INFO,
WARN,
ERROR,
FATAL
}

/// <summary>
/// 日志内容，参考 myLogEntryWrittenArgs
/// </summary>
public class myEventLogEntry
{
/// <summary>
/// 日志源，用以记载日志的来源
/// </summary>
public string Source = "";
/// <summary>
/// 日志内容
/// </summary>
public string Message = "";
/// <summary>
/// 写入日志的时间
/// </summary>
public DateTime TimeWritten = DateTime.Now;
/// <summary>
/// 日志的类型，可以参考 EventLogEntryType 的定义
/// </summary>
public enumLevel Type = enumLevel.INFO;
}

/// <summary>
/// 日志外部处理函数的参数
/// </summary>
public class myLogEntryWrittenArgs : EventArgs
{
public myLogEntryWrittenArgs()
{
Entry = new myEventLogEntry();
}

public myEventLogEntry Entry;
}

/// <summary>
/// 日志外部的处理入口函数声明
/// </summary>
public delegate void myLogEntryWrittenHandler( object sender, myLogEntryWrittenArgs e );

/// <summary>
///
/// 根据日志输出级别写日志
///
/// 特性：
///
/// 1、可以根据日志输出级别写日志
///
/// 日志的输出级别：DEBUG < INFO < WARN < ERROR < FATAL
///
/// 例如，日志级别是 INFO，则调用 debug() 不会输出，调用其他方法会输出；
/// 日志级别是 WARN，则调用 debug() 和 info() 不会输出，调用其他方法会输出。
///
/// 2、写日志时调用外部处理入口
///
/// 可以添加外部处理入口函数（声明见 myLogEntryWrittenHandler ），在写日志时，程序
/// 依次调用外部处理入口函数，调用着可以在外部处理入口函数中得到日志的相关信息。
/// 这里使用了观察者模式。
///
/// 例如：
/// private static ILogger logger = CLoggerFactory.getLogger();
/// public void logEntryWritten(object sender, myLogEntryWrittenArgs e)
/// {
/// //......
/// }
/// logger.addEntryWrittenHander( new myLogEntryWrittenHandler(this.logEntryWritten) );
///
/// 那么在写日志的时候，logEntryWritten()会被调用。
///
/// </summary>
public interface ILogger
{
// 写日志
void debug( string message, string source );
void info ( string message, string source );
void warn ( string message, string source );
void error( string message, string source );
void fatal( string message, string source );

// 设置和返回日志输出级别
void setLevel(enumLevel level);
enumLevel getLevel();

// 管理外部程序处理入口
void addEntryWrittenHander( Delegate handler );
void clearEntryWrittenHander();
void enableEntryWrittenHander( bool enabled );
}
}

3、CLoggerAbstract.cs

using System;
using System.IO;
using System.Diagnostics;
using System.Collections;

namespace com.lenovo.zhangyuk.logger
{
/// <summary>
/// 日志处理的抽象类
///
/// 这里使用了基于继承的模板模式
/// 在CLoggerAbstract中实现了向各种日志源输出的通用操作
/// 向具体日志源输出的动作则通过虚函数_writeLog在子类实现
/// </summary>
abstract class CLoggerAbstract : ILogger
{
// 写日志时触发外部方法的HANDLE
private static ArrayList _entryWrittenEventHandler = new ArrayList();

// 写日志时是否触发外部方法
private static bool _bEnableEntryWritten = true;

// 日志输出级别，默认是 INFO
private static enumLevel _outputLevel = enumLevel.INFO;

// 抽象函数，具体的写日志操作由子类实现
public abstract void _writeLog(string message, string source, enumLevel type);

/// <summary>
/// 构造函数
/// </summary>
/// <param name="strEventSource"></param>
/// <param name="strEventLog"></param>
public CLoggerAbstract( enumLevel level )
{
_outputLevel = level;
}

/// <summary>
/// 设置日志输出级别
/// </summary>
/// <param name="level">级别</param>
public void setLevel(enumLevel level)
{
_outputLevel = level;
}

/// <summary>
/// 获得日志输出级别
/// </summary>
/// <returns>级别</returns>
public enumLevel getLevel()
{
return _outputLevel;
}

/// <summary>
/// 写调试信息
/// </summary>
/// <param name="message"></param>
public void debug( string message, string source )
{
if( _outputLevel <= enumLevel.DEBUG )
write( message, source, enumLevel.DEBUG );
}

/// <summary>
/// 写一般信息
/// </summary>
/// <param name="message"></param>
public void info( string message, string source )
{
if( _outputLevel <= enumLevel.INFO )
write( message, source, enumLevel.INFO );
}

/// <summary>
/// 写警告信息
/// </summary>
/// <param name="message"></param>
public void warn( string message, string source )
{
if( _outputLevel <= enumLevel.WARN )
write( message, source, enumLevel.WARN );
}

/// <summary>
/// 写错误信息
/// </summary>
/// <param name="message"></param>
public void error( string message, string source )
{
if( _outputLevel <= enumLevel.ERROR )
write( message, source, enumLevel.ERROR );
}

/// <summary>
/// 写严重错误信息
/// </summary>
/// <param name="message"></param>
public void fatal( string message, string source )
{
if( _outputLevel <= enumLevel.FATAL )
write( message, source, enumLevel.FATAL );
}

/// <summary>
/// 设置写日志时触发的外部方法
/// </summary>
/// <param name="handler">外部方法HANDLE</param>
public void addEntryWrittenHander( Delegate handler )
{
try
{
if( !_entryWrittenEventHandler.Contains(handler) )
_entryWrittenEventHandler.Add( handler );
}
catch( Exception ex )
{
this.warn("add entry written hander error:"+ex.Message, this.ToString());
}
}

/// <summary>
/// 清除写日志时触发的外部方法
/// </summary>
public void clearEntryWrittenHander()
{
try
{
_entryWrittenEventHandler.Clear();
}
catch( Exception ex )
{
this.warn("clear entry written hander error:"+ex.Message, this.ToString());
}
}

/// <summary>
/// 设置是否在写日志时触发的外部方法，默认为TRUE。
/// </summary>
/// <param name="enabled">是否</param>
public void enableEntryWrittenHander( bool enabled )
{
_bEnableEntryWritten = enabled;
}

/// <summary>
/// 将控制转给外部处理方法
/// </summary>
/// <param name="source"></param>
/// <param name="e"></param>
private void OnEntryWritten( string message, string source, enumLevel type)//object source, EntryWrittenEventArgs e)
{
if( _entryWrittenEventHandler.Count >0 )
{
myLogEntryWrittenArgs args = new myLogEntryWrittenArgs();
args.Entry.TimeWritten = DateTime.Now;
args.Entry.Message = message;
args.Entry.Type = type;
args.Entry.Source = source;
foreach( myLogEntryWrittenHandler aHandler in _entryWrittenEventHandler )
{
aHandler( this, args );
}
}
}

/// <summary>
/// 写事件日志
/// </summary>
/// <param name="strMessage">事件内容</param>
/// <param name="eventType">事件类别，错误、警告或者消息</param>
private void write( string message, string source, enumLevel type )
{
try
{
_writeLog( message, source, type );
OnEntryWritten( message, source, type );
}
catch( Exception ex )
{
Trace.WriteLine("Write logger error:" + ex.Message);
}
}
}
}

4、CLoggerDatabase.cs

using System;
using System.IO;
using System.Diagnostics;
using System.Data;
using System.Data.OleDb;

namespace com.lenovo.zhangyuk.logger
{
/// <summary>
/// 向数据库写日志
/// </summary>
class CLoggerDatabase : CLoggerAbstract
{
// 数据库连接
private static OleDbConnection _connection = null;
// 向数据库写日志的带参数的SQL串，通常是一条带参数的INSERT语句
private static string _updateStr = "";

/// <summary>
/// 构造函数
/// </summary>
/// <param name="strUpdate">向数据库写日志的带参数的SQL串，通常是一条带参数的INSERT语句</param>
/// <param name="level">日志输出的级别</param>
public CLoggerDatabase( string strUpdate, enumLevel level ) : base(level)
{
if( null == _connection )
{
_connection = new OleDbConnection(CConfiguration.getConfiguration("database.connectionString"));
}
Trace.WriteLineIf( ( strUpdate.Length <=0 ), "error : update string is empty !" );
_updateStr = strUpdate;
}

/// <summary>
/// 向数据库写日志
/// override抽象类的相应函数
/// </summary>
/// <param name="message">日志内容</param>
/// <param name="source">日志源</param>
/// <param name="type">日志级别</param>
public override void _writeLog(string message, string source, enumLevel type)
{
try
{
OleDbCommand command = new OleDbCommand();
command.Connection = _connection;
command.CommandText = string.Format(_updateStr,
DateTime.Now.ToLocalTime(),
message,
source,
type.ToString());
command.CommandType = CommandType.Text;

_connection.Open();
command.ExecuteNonQuery();
_connection.Close();
}
catch( Exception ex )
{
_connection.Close();
throw ex;
}
}
}
}
5、CLoggerFile.cs

using System;
using System.IO;
using System.Diagnostics;

namespace com.lenovo.zhangyuk.logger
{
/// <summary>
/// 向文件写日志
/// </summary>
class CLoggerFile : CLoggerAbstract
{
// 文件句柄
private static Stream _fileStream = null;

/// <summary>
/// 构造函数
/// </summary>
/// <param name="strFileName">日志文件名</param>
/// <param name="level">日志输出的级别</param>
public CLoggerFile( string strFileName, enumLevel level ) : base(level)
{
Trace.WriteLineIf( ( strFileName.Length <=0 ), "error : logger file name is empty !" );

if( null == _fileStream )
{
_fileStream = new FileStream(strFileName, FileMode.OpenOrCreate, FileAccess.Write );
}
}

/// <summary>
/// 向文件写日志
/// override抽象类的相应函数
/// </summary>
/// <param name="message">日志内容</param>
/// <param name="source">日志源</param>
/// <param name="type">日志级别</param>
public override void _writeLog(string message, string source, enumLevel type)
{
try
{
_fileStream.Seek(0,SeekOrigin.End);
StreamWriter sw = new StreamWriter(_fileStream);
sw.WriteLine( DateTime.Now.ToString() + " " + type.ToString() + " " + source + " " + message);
sw.Flush();
}
catch( Exception ex )
{
throw ex;
}
}
}
}
6、CLoggerEvent.cs

using System;
using System.Diagnostics;

namespace com.lenovo.zhangyuk.logger
{
/// <summary>
/// 向系统写入日志
/// </summary>
class CLoggerEvent : CLoggerAbstract
{
// 事件日志
private static EventLog _eventLog = new EventLog();
// 事件日志名
private static string _eventName = "com.lenovo.zhangyu";

/// <summary>
/// 构造函数
/// </summary>
/// <param name="strEventName">事件日志名</param>
/// <param name="level">日志输出的级别</param>
public CLoggerEvent( string strEventName, enumLevel level ) : base(level)
{
_eventName = strEventName;
_eventLog.Log = _eventName;
_eventLog.EnableRaisingEvents = false;
}

/// <summary>
/// 向系统写入日志
/// override抽象类的相应函数
/// </summary>
/// <param name="message">日志内容</param>
/// <param name="source">日志源</param>
/// <param name="type">日志级别</param>
public override void _writeLog(string message, string source, enumLevel type)
{
try
{
if (!EventLog.SourceExists( source ))
{
EventLog.CreateEventSource( source,_eventName );
}
_eventLog.Source = source;
_eventLog.WriteEntry( message, myType2EventType( type ) );
}
catch( Exception ex )
{
throw ex;
}
}

/// <summary>
/// 将自定义的日志级别转换为系统约定的日志级别
/// DEBUG INFO --> Information
/// ERROR FATAL --> Error
/// WARN --> Warning
/// </summary>
/// <param name="type">自定义的日志级别</param>
/// <returns>系统约定的日志级别</returns>
private EventLogEntryType myType2EventType( enumLevel type )
{
EventLogEntryType eventType = EventLogEntryType.Information;
if( type == enumLevel.DEBUG || type == enumLevel.INFO )
eventType = EventLogEntryType.Information;
else if( type == enumLevel.ERROR || type == enumLevel.FATAL )
eventType = EventLogEntryType.Error;
else if( type == enumLevel.WARN )
eventType = EventLogEntryType.Warning;
return eventType;
}
}
}
7、CLoggerFactory.cs

using System;
using System.Collections;
using System.Reflection;

namespace com.lenovo.zhangyuk.logger
{
/// <summary>
/// CLoggerFactory 的摘要说明。
/// </summary>
public class CLoggerFactory
{
private CLoggerFactory()
{
}

/// <summary>
/// 根据配置文件中的设置创建日志类
/// </summary>
/// <returns></returns>
public static ILogger getLogger()
{
// 日志类型
string logger = CConfiguration.getConfiguration("logger.type");
// 日志名或日志文件名
string loggerName = CConfiguration.getConfiguration("logger.name");
// 日志级别
enumLevel level = str2enum( CConfiguration.getConfiguration("logger.level") );

// 创建日志类
if( logger.ToLower().Equals("file") ) // 文件日志
{
return new CLoggerFile( loggerName, level );
}
else if( logger.ToLower().Equals("database") ) // 数据库日志
{
return new CLoggerDatabase( loggerName, level );
}
else// if( logger.ToLower().Equals("system") ) // 缺省使用系统日志
{
return new CLoggerEvent( loggerName, level );
}
}

/// <summary>
/// 将string类型的日志输出级别转换成程序可识别的enum型
/// </summary>
/// <param name="strLevel">string类型的日志输出级别</param>
/// <returns>enumLevel类型的日志输出级别</returns>
private static enumLevel str2enum( string strLevel )
{
enumLevel level = 0;

if( strLevel.ToLower().Equals("debug") )
level = enumLevel.DEBUG;
else if( strLevel.ToLower().Equals("info") )
level = enumLevel.INFO;
else if( strLevel.ToLower().Equals("warn") )
level = enumLevel.WARN;
else if( strLevel.ToLower().Equals("error") )
level = enumLevel.ERROR;
else if( strLevel.ToLower().Equals("fatal") )
level = enumLevel.FATAL;
else
level = enumLevel.INFO;

return level;
}
}
}
8、

<?xml version="1.0" encoding="gb2312"?>
<configuration>
<appSettings>
<add key="database.connectionString" value="Provider=OraOLEDB.Oracle.1;Password=zy;User ID=zy;Data Source=mytest" />
<add key="logger.type" value="file" />
<add key="logger.level" value="debug" />
<add key="logger.name" value="c://mylog.txt"/>
</appSettings>
</configuration>