public static void Log(LogLevelEnum logLevel, string msg, params object[] args)
{
if (!LoggingEnabled) return; // No logging allowed..
if(args != null)
{
if(args.Length > 0)
msg = string.Format(msg, args);
}
switch(logLevel)
{
case LogLevelEnum.DEBUG:
logger.Debug(msg);
break;
case LogLevelEnum.INFO:
logger.Info(msg);
break;
case LogLevelEnum.WARN:
logger.Warn(msg);
break;
case LogLevelEnum.ERROR:
logger.Error(msg);
break;
case LogLevelEnum.FATAL:
logger.Fatal(msg);
break;
}
}
/// <summary>
/// 日志构造函数
/// </summary>
/// <param name="loglevel"></param>
/// <param name="msg"></param>
/// <param name="msgKey"></param>
/// <param name="moduleName"></param>
internal LogInfo(LogLevelEnum loglevel, object msg, string msgKey = null, string moduleName = ModuleNames.Default)
{
Level = loglevel;
ModuleName = moduleName;
Msg = msg;
MsgKey = msgKey;
}
public void LogMessage(LogLevelEnum messageLogLevel, String format, params object[] args)
{
if (_logLevel == LogLevelEnum.logNothing) return;
String message = String.Format(format, args);
switch (messageLogLevel)
{
case LogLevelEnum.logError:
// Always log an error
LogToFile(messageLogLevel, message);
break;
case LogLevelEnum.logWarning:
if ((_logLevel == LogLevelEnum.logWarning) ||
(_logLevel == LogLevelEnum.logDebug))
{
// Only log a warning at warning and debug level
LogToFile(messageLogLevel, message);
}
break;
case LogLevelEnum.logDebug:
if (_logLevel == LogLevelEnum.logDebug)
{
// Only log a debug at debug level
LogToFile(messageLogLevel, message);
}
break;
default:
break;
}
}
private TraceEventType ConvertToTraceEventType(LogLevelEnum level)
{
// Declaration
TraceEventType resultLevel;
// Initialization
resultLevel = TraceEventType.Information;
// Implementation
switch (level)
{
case LogLevelEnum.Information:
resultLevel = TraceEventType.Information;
break;
case LogLevelEnum.Warning:
resultLevel = TraceEventType.Warning;
break;
case LogLevelEnum.Error:
resultLevel = TraceEventType.Error;
break;
case LogLevelEnum.Critical:
resultLevel = TraceEventType.Critical;
break;
default:
break;
}
return resultLevel;
}
public ApplicationInsightLoggerFactory(
LogLevelEnum defaultMinimumLogLevel,
IFullyQualifiedName defaultLoggerSource)
{
_defaultMinimumLogLevel = defaultMinimumLogLevel;
_defaultLoggerSource = defaultLoggerSource;
}
public void Log(LogLevelEnum level, string message, params object[] additionalData)
{
if (level >= _minimumLogLevel)
{
string source = _source?.FullyQualifiedName ?? "default";
Console.WriteLine($"{source} - {level.ToString().ToUpper()} : {string.Format(message, additionalData)}");
}
}
public static IDependencyResolver UseAzureApplicationInsightsLogger(
this IDependencyResolver dependencyResolver,
LogLevelEnum defaultMinimumLogLevel = LogLevelEnum.Warning,
IFullyQualifiedName defaultLoggerSource = null)
{
return dependencyResolver
.Register<ILoggerFactory>(() => new ApplicationInsightLoggerFactory(defaultMinimumLogLevel, defaultLoggerSource))
.Register(() => new ApplicationInsightLoggerFactory(defaultMinimumLogLevel, defaultLoggerSource).CreateLogger());
}
public Task LogAsync(LogLevelEnum level, string message, params object[] additionalData)
{
if (level >= _minimumLogLevel)
{
string source = _source?.FullyQualifiedName ?? "default";
Write(level, $"{source} - {level.ToString().ToUpper()} : {string.Format(message, additionalData)}");
}
return Task.FromResult(0);
}
public ILogger CreateLogger(IFullyQualifiedName source, LogLevelEnum? minimumLogLevel = null)
{
return new AzureQueueLogger.Implementation.QueueLogger(_runtimeEnvironment,
GetQueue(),
_queueSerializer,
source ?? _defaultLoggerSource,
_queueLoggerExtension,
minimumLogLevel.GetValueOrDefault(_defaultMinimumLogLevel),
_correlationIdProvider);
}
public global::Serilog.ILogger CreateSerilog(IFullyQualifiedName source, LogLevelEnum? minimumLogLevel = null)
{
LoggerConfiguration loggerConfiguration = GetLoggerConfiguration(minimumLogLevel);
source = source ?? _defaultLoggerSource;
if (source != null)
{
loggerConfiguration.Enrich.With(new FullyQualifiedNameEnricher(source, _sourceFqnPropertyName));
}
return new LoggerFacade(loggerConfiguration.CreateLogger());
}
///<inheritdoc/>
public override void WriteLog(LogLevelEnum logLevel, string msg)
{
if( sw != null )
{
if (logLevel >= MinLogLevel)
{
sw.WriteLine(msg);
if (!isAutoFlush)
sw.Flush();
}
}
}
/// <summary>
/// Logs the message.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="level">The level of message Severity.</param>
public void LogMessage(string message, LogLevelEnum loglevel)
{
// Declaration
TraceEventType level;
// Implementation
if (loglevel.CompareTo(loggerLevel) >= 0)
{
level = ConvertToTraceEventType(loglevel);
writeLog(message, level);
}
}
/// <summary>
/// Register Serilog as the frameworks default logger.
/// </summary>
/// <param name="dependencyResolver">Dependency resolver to register Serilog in</param>
/// <param name="configurationProvider">A function that returns a SeriLog LoggerConfiguration class.
/// If null then Serilog is configured to write using the Trace sink. Note that a LoggerConfiguration returned from this function
/// will be further annotated with a minimum log level and property enrichment for correlation ID and source. If you don't want
/// any of that then use the CreateSerilog(LoggerConfiguration loggerConfiguration) on ISerilogFactory</param>
/// <param name="defaultMinimumLogLevel">The default minimum log level for loggers created by the factory</param>
/// <param name="defaultLoggerSource">The component source to use for a logger when no source is specified - defaults to null.</param>
/// <param name="sourceFqnPropertyName">The Serilog property name for the source component fully qualified name</param>
/// <param name="correlationIdPropertyName">The Serilog property name for the correlation ID</param>
/// <returns></returns>
public static IDependencyResolver UseSerilog(this IDependencyResolver dependencyResolver,
Func<LoggerConfiguration> configurationProvider = null,
LogLevelEnum defaultMinimumLogLevel = LogLevelEnum.Warning,
IFullyQualifiedName defaultLoggerSource = null,
string sourceFqnPropertyName = "SourceFqn",
string correlationIdPropertyName = "CorrelationId")
{
return dependencyResolver
.Register<ILoggerFactory>(() => new SerilogFactory(configurationProvider, dependencyResolver.Resolve<ICorrelationIdProvider>(), defaultMinimumLogLevel, defaultLoggerSource, sourceFqnPropertyName, correlationIdPropertyName))
.Register<ISerilogFactory>(() => new SerilogFactory(configurationProvider, dependencyResolver.Resolve<ICorrelationIdProvider>(), defaultMinimumLogLevel, defaultLoggerSource, sourceFqnPropertyName, correlationIdPropertyName))
.Register(() => new SerilogFactory(configurationProvider, dependencyResolver.Resolve<ICorrelationIdProvider>(), defaultMinimumLogLevel, defaultLoggerSource, sourceFqnPropertyName, correlationIdPropertyName).CreateLogger())
.Register(() => new SerilogFactory(configurationProvider, dependencyResolver.Resolve<ICorrelationIdProvider>(), defaultMinimumLogLevel, defaultLoggerSource, sourceFqnPropertyName, correlationIdPropertyName).CreateSerilog());
}
/// <summary>
/// Register the dependencies in a container
/// </summary>
/// <param name="container">The container to use</param>
/// <param name="correlationIdKey">The correlation ID key. Defaults to correlation-id</param>
/// <param name="defaultTraceLoggerMinimumLogLevel"></param>
/// <param name="defaultLoggerSource">The component source to use for a default logger when no source is specified - defaults to null.</param>
public static IDependencyResolver UseCore(
this IDependencyResolver container,
string correlationIdKey = "correlation-id",
LogLevelEnum defaultTraceLoggerMinimumLogLevel = LogLevelEnum.Warning,
IFullyQualifiedName defaultLoggerSource = null)
{
Func<ICorrelationIdProvider> createCorrelationIdProvider;
if (!string.IsNullOrWhiteSpace(correlationIdKey))
{
createCorrelationIdProvider = () => new CallContextCorrelationIdProvider(correlationIdKey);
}
else
{
createCorrelationIdProvider = () => new NullCorrelationIdProvider();
}
return container
.Register<IAsynchronousDelay, AsynchronousDelay>()
.Register<ITimerThreadPoolExecuter, TimerThreadPoolExecuter>()
.Register<ITimerFactory, TimerFactory>()
.Register<IBackoffPolicy, BackoffPolicy>()
.Register<IBackoffPolicyTimingProvider, BackoffPolicyDefaultTimingProvider>()
.Register<IAsynchronousBackoffPolicy, AsynchronousBackoffPolicy>()
.Register<IBackoffPolicyFactory, BackoffPolicyFactory>()
.Register<ILeasedRetry, LeasedRetry>()
.Register<IWaitHandle, ManualResetEventWaitHandle>()
.Register<IApplicationResourceSettingNameProvider, ApplicationResourceSettingNameProvider>()
.Register<IAsyncApplicationResourceSettingProvider, AsyncApplicationResourceSettingProvider>()
.Register<IAsyncApplicationResourceFactory, AsyncApplicationResourceFactory>()
.Register<IApplicationResourceFactory, ApplicationResourceFactory>()
.Register<IApplicationResourceSettingProvider, ApplicationResourceSettingProvider>()
.Register<IQueueFactory, NotSupportedQueueFactory>()
.Register<ILeaseManagerFactory, NotSupportedLeaseManagerFactory>()
.Register<IBlobRepositoryFactory, NotSupportedBlobRepositoryFactory>()
.Register(createCorrelationIdProvider)
.Register<ILoggerFactory>(() => new TraceLoggerFactory(defaultTraceLoggerMinimumLogLevel, defaultLoggerSource))
.Register(() => new TraceLoggerFactory(defaultTraceLoggerMinimumLogLevel, defaultLoggerSource).CreateLogger())
.Register(() => new TraceLoggerFactory(defaultTraceLoggerMinimumLogLevel, defaultLoggerSource).CreateAsynchronousLogger(defaultTraceLoggerMinimumLogLevel))
.Register<IComponentHost, ComponentHost>()
.Register<IEmailQueueDispatcher, EmailQueueDispatcher>()
.Register<IUnitOfWorkFactoryProvider, NotSupportedUnitOfWorkFactoryProvider>()
.Register<IRuntimeEnvironment, DefaultRuntimeEnvironment>()
.Register<IConfiguration>(() => new DefaultConfiguration())
.Register<IAsyncConfiguration>(() => new DefaultAsyncConfiguration())
.Register<IComponentFactory>(() => new ComponentFactory(container))
.Register<IComponentHostRestartHandler, DefaultComponentHostRestartHandler>()
.Register<ILargeMessageQueueFactory, LargeMessageQueueFactory>()
// internal
.Register<ICoreAssemblyLogger>(() =>
new CoreAssemblyLogger(container.Resolve<ILoggerFactory>().CreateLogger(new LoggerSource("AccidentalFish.ApplicationSupport.Core"))));
}
public SerilogFactory(Func<LoggerConfiguration> loggerConfigurationProvider,
ICorrelationIdProvider correlationIdProvider,
LogLevelEnum defaultMinimumLogLevel,
IFullyQualifiedName defaultLoggerSource,
string sourceFqnPropertyName,
string correlationIdPropertyName)
{
_loggerConfigurationProvider = loggerConfigurationProvider;
_correlationIdProvider = correlationIdProvider;
_defaultMinimumLogLevel = defaultMinimumLogLevel;
_defaultLoggerSource = defaultLoggerSource;
_sourceFqnPropertyName = sourceFqnPropertyName;
_correlationIdPropertyName = correlationIdPropertyName;
}
private LoggerConfiguration GetLoggerConfiguration(LogLevelEnum? minimumLogLevel)
{
var configuration = _loggerConfigurationProvider != null ?
_loggerConfigurationProvider() :
new LoggerConfiguration().WriteTo.Trace();
configuration
.MinimumLevel
.Is(minimumLogLevel.GetValueOrDefault(_defaultMinimumLogLevel).ToLogEventLevel())
.Enrich.With(new CorrelationIdEnricher(_correlationIdProvider, _correlationIdPropertyName))
.Enrich.WithThreadId()
.Enrich.WithProcessId()
.Enrich.WithMachineName();
return configuration;
}
private static ILoggerFactory GetLoggerFactory(
IDependencyResolver dependencyResolver,
LogLevelEnum defaultMinimumLogLevel,
IFullyQualifiedName defaultLoggerSource)
{
IRuntimeEnvironment runtimeEnvironment = dependencyResolver.Resolve<IRuntimeEnvironment>();
IConfiguration configuration = dependencyResolver.Resolve<IConfiguration>();
IQueueLoggerExtension queueLoggerExtension = dependencyResolver.Resolve<IQueueLoggerExtension>();
ICorrelationIdProvider correlationIdProvider = dependencyResolver.Resolve<ICorrelationIdProvider>();
IQueueSerializer queueSerializer = dependencyResolver.Resolve<IQueueSerializer>();
IApplicationResourceSettingNameProvider nameProvider = dependencyResolver.Resolve<IApplicationResourceSettingNameProvider>();
return new QueueLoggerFactory(runtimeEnvironment, nameProvider, configuration, queueSerializer, queueLoggerExtension,
correlationIdProvider, defaultMinimumLogLevel, defaultLoggerSource);
}
public static IDependencyResolver UseQueueLogger(this IDependencyResolver dependencyResolver,
Type loggerExtension = null,
LogLevelEnum defaultMinimumLogLevel = LogLevelEnum.Warning,
IFullyQualifiedName defaultLoggerSource = null)
{
if (loggerExtension == null)
{
loggerExtension = typeof (NullQueueLoggerExtension);
}
return dependencyResolver
.Register(typeof (IQueueLoggerExtension), loggerExtension)
.Register(() => GetLoggerFactory(dependencyResolver, defaultMinimumLogLevel, defaultLoggerSource))
.Register(() => GetLoggerFactory(dependencyResolver, defaultMinimumLogLevel, defaultLoggerSource).CreateLogger())
.Register(() => GetLoggerFactory(dependencyResolver, defaultMinimumLogLevel, defaultLoggerSource).CreateAsynchronousLogger());
}
public Task Log(LogLevelEnum level, string message, Exception exception)
{
if (level < _minimumLogLevel) return Task.FromResult(0);
Dictionary<string, string> properties = new Dictionary<string, string>
{
{"component", _fullyQualifiedName.ToString()},
{"level", level.ToString()},
{"message", message}
};
if (exception != null)
{
_telemetryClient.TrackException(exception, properties);
}
_telemetryClient.TrackEvent($"LOG:{level}", properties);
return Task.FromResult(0);
}
public QueueLoggerFactory(
IRuntimeEnvironment runtimeEnvironment,
IApplicationResourceSettingNameProvider nameProvider,
IConfiguration configuration,
IQueueSerializer queueSerializer,
IQueueLoggerExtension queueLoggerExtension,
ICorrelationIdProvider correlationIdProvider,
LogLevelEnum defaultMinimumLogLevel,
IFullyQualifiedName defaultLoggerSource)
{
_runtimeEnvironment = runtimeEnvironment;
_queueSerializer = queueSerializer;
_queueLoggerExtension = queueLoggerExtension;
_correlationIdProvider = correlationIdProvider;
_defaultMinimumLogLevel = defaultMinimumLogLevel;
_defaultLoggerSource = defaultLoggerSource;
_queueName = configuration[nameProvider.SettingName(ApplicationSupportComponentIdentity, "logger-queue")];
_storageAccountConnectionString = configuration[nameProvider.StorageAccountConnectionString(ApplicationSupportComponentIdentity)];
}
private LogLevel ToLogLevel( LogLevelEnum ll )
{
switch( ll ) {
case LogLevelEnum.Debug:
return LogLevel.Debug;
case LogLevelEnum.Error:
return LogLevel.Error;
case LogLevelEnum.Fatal:
return LogLevel.Fatal;
case LogLevelEnum.Info:
return LogLevel.Info;
case LogLevelEnum.Off:
return LogLevel.Off;
case LogLevelEnum.Trace:
return LogLevel.Trace;
case LogLevelEnum.Warn:
return LogLevel.Warn;
default:
return LogLevel.Off;
}
}
public static void LogMessage(Type type, LogLevelEnum logLevel, string message, Exception ex)
{
Log = LogManager.GetLogger(type);
switch(logLevel)
{
case LogLevelEnum.Debug:
#if DEBUG
Log.Debug(message, ex);
#endif
break;
case LogLevelEnum.Error:
Log.Error(message, ex);
break;
case LogLevelEnum.Fatal:
Log.Fatal(message, ex);
break;
case LogLevelEnum.Info:
Log.Info(message, ex);
break;
case LogLevelEnum.Warn:
Log.Warn(message, ex);
break;
}
}
public static void ShowMsgInInfoWindow(TextBox showWin, LogLevelEnum nMsgType, System.String strMsg)
{
System.String strOldTest = System.String.Empty;
System.String strShowInfo = System.String.Empty;
//System.DateTime nTimeNow = System.DateTime.Now;
System.String strMsgType = System.String.Empty;
strOldTest = showWin.Text;
switch (nMsgType)
{
case LogLevelEnum.LOG_WARN:
strMsgType = " WARN: ";
break;
case LogLevelEnum.LOG_INFO:
strMsgType = " INFO: ";
break;
case LogLevelEnum.LOG_ERROR:
strMsgType = " ERROR: ";
break;
default:
strMsgType = " INFO: ";
break;
}//switch
strShowInfo = strOldTest;
//add Msg to tail
//Millisecond
strShowInfo += System.DateTime.Now.ToString("\n yyyy-MM-dd HH:mm:ss.fff -- ");
//strShowInfo = System.DateTime.Now.Millisecond.ToString();
strShowInfo += strMsgType;
strShowInfo += strMsg;
showWin.Text = strShowInfo;
}
public void Log(LogLevelEnum level, string message)
{
Log(new LogEntity(message, level));
}
internal override IEnumerable <ConfigurationPoint> GetConfigPoints(LogLevelEnum logLevel)
{
return(LogLevelXPaths.Select(item => CreateConfigurationPoint(item, logLevel)));
}
public DislyEventArgs(LogLevelEnum eventLevel, String message, Exception exception = null)
{
EventLevel = eventLevel;
Message = message;
Exception = exception;
}
public LogMessage(LogLevelEnum logLevel, Dictionary <string, string> messages)
: base(Methods.LOG_MESSAGE)
{
this.logLevel = logLevel;
this.messages = messages;
}
protected static void Log(LogLevelEnum logLevel, string message, FileLoggerConfiguration configuration)
{
FileLogger fileLogger = FileLogger.Instance(configuration);
fileLogger.WriteLog(logLevel, message);
}
public static ILogLevel ToLogLevel(this LogLevelEnum logLevelEnum)
{
return(new LogLevel(logLevelEnum));
}
public override void doLogMessages(LogLevelEnum loglevel, Dictionary <string, string> messages)
{
//TODO: implement
}
public ILogger CreateLogger(IFullyQualifiedName source, LogLevelEnum? minimumLogLevel = null)
{
return new TraceLogger(source ?? _defaultLoggerSource, minimumLogLevel.GetValueOrDefault(_defaultMinimumLogLevel));
}
public LogLevel(LogLevelEnum logLevel) : this(logLevel.ToString(), (int)logLevel)
{
}
public static void WriteLine(string text = "", LogLevelEnum level = LogLevelEnum.DEBUG, string additionalDestinationFile = null)
{
Write(text + "\n", level, additionalDestinationFile);
}
/// <summary>
/// Creates an instance of the Serilog configuration.
/// </summary>
/// <param name="loglevel">Defaults to Information</param>
public SerilogConfig(LogLevelEnum loglevel = LogLevelEnum.INFO)
{
LogLevel = loglevel;
}
public IAsynchronousLogger CreateAsynchronousLogger(IFullyQualifiedName source, LogLevelEnum? minimumLogLevel)
{
return new ConsoleAsynchronousLogger(source ?? _defaultLoggerSource, minimumLogLevel.GetValueOrDefault(_defaultMinimumLoggingLevel));
}
/// <summary>
/// 判断是否需要写入日志
/// </summary>
/// <param name="level">级别</param>
/// <param name="recordLogLevel">记录日志级别</param>
/// <returns>是否需要写入日志</returns>
public static bool IsNeedWriteLog(string level, string recordLogLevel)
{
LogLevelEnum levelEnum = Parse(level);
return(levelEnum >= Parse(recordLogLevel));
}
public virtual void Log(string message, LogLevelEnum logLevel = LogLevelEnum.Info, object parameters = null)
{
new LogService().Log(message, logLevel, parameters);
}
protected static List <LogRecord> Parse(LogLevelEnum logLevel, FileLoggerConfiguration configuration)
{
FileLogger fileLogger = FileLogger.Instance(configuration);
return(fileLogger.Parse(logLevel));
}
public static void Log(LogLevelEnum logLevel, string message)
{
Log(logLevel, message, Settings.Instance.LoggerConfiguration);
}
public IAsynchronousLogger CreateAsynchronousLogger(LogLevelEnum? minimumLogLevel)
{
return new TraceAsynchronousLogger(null, minimumLogLevel.GetValueOrDefault(_defaultMinimumLogLevel));
}
public IAsynchronousLogger CreateAsynchronousLogger(LogLevelEnum? minimumLogLevel)
{
return new ConsoleAsynchronousLogger(_defaultLoggerSource, minimumLogLevel.GetValueOrDefault(_defaultMinimumLoggingLevel));
}
public static void SetLogLevel(LogLevelEnum logLevel)
{
LogLevel = logLevel;
}
public ConsoleLogger(IFullyQualifiedName source, LogLevelEnum minimumLogLevel)
{
_source = source;
_minimumLogLevel = minimumLogLevel;
}
public abstract void doLogMessages(LogLevelEnum logLevel, Dictionary <string, string> messages);
public override void doLogMessages(LogLevelEnum logLevel, Dictionary <string, string> messages)
{
sendObjectMessage(new LogMessage(logLevel, messages));
}
public void Log(string info, LogLevelEnum LogLevel = LogLevelEnum.Info)
{
OnOnLog(info, LogLevel);
}
public ILogger CreateLogger(LogLevelEnum? minimumLogLevel = null)
{
return new TraceLogger(_defaultLoggerSource, minimumLogLevel.GetValueOrDefault(_defaultMinimumLogLevel));
}
//************************************************************************
/// <summary>
/// Data Class内容LOG输出
/// <param name="argLoglevel">LOG级别</param>
/// <param name="argFqcn">Class名</param>
/// <param name="argMethodName">method名</param>
/// <param name="argDataName">Data名</param>
/// <param name="argDataObject">dataobject</param>
/// <param name="argUserID">用户名</param>
/// <param name="argIpAddress">IPAddress</param>
/// </summary>
//************************************************************************
private void WriteDataLog(LogLevelEnum argLoglevel, string argFqcn, string argMethodName, string argDataName, object argDataObject)
{
string strMessage = "";
// Data Object为null时、NULL输出返回
if (argDataObject == null)
{
strMessage = argDataName + "\t" + "NULL";
WriteLogFile(argLoglevel, argFqcn, argMethodName, strMessage, null);
return;
}
#region 反射写出数据
// object的类型取得
Type classType = argDataObject.GetType();
// 基本型时
if (isBaseType(classType))
{
// 基本型时
strMessage = argDataName + "\t" + "[" + classType.Name + "]";
strMessage += "\t" + "[" + argDataObject.ToString() + "]";
WriteLogFile(argLoglevel, argFqcn, argMethodName, strMessage, null);
return;
}
// Array时
if (classType.IsArray)
{
long[] indexArray = null;;
int intArrayLength = ((Array)argDataObject).Length;
for (int index = 0; index < intArrayLength; index++)
{
indexArray = getArrayMember((Array)argDataObject, index);
object arrayObj = ((Array)argDataObject).GetValue(indexArray);
// Array的名称取得
string objName = argDataName + "[" + indexArray[0].ToString();
for (int i = 1; i < indexArray.Length; i++)
{
objName += "," + indexArray[i].ToString();
}
objName += "]";
// Array的名称为NUll时
if (arrayObj == null)
{
strMessage = objName + "\t" + "[" + argDataObject.GetType().GetElementType().Name + "]";
strMessage += "\t" + "NULL";
WriteLogFile(argLoglevel, argFqcn, argMethodName, strMessage, null);
}
else
{
WriteDataLog(argLoglevel, argFqcn, argMethodName, objName, arrayObj);
}
}
return;
}
string strSpace = "";
for (int temp = 0; temp < argDataName.Length; temp++)
{
if (argDataName.Substring(temp, 1) == " ")
{
strSpace += " ";
}
else if (argDataName.Substring(temp, 1) == " ")
{
strSpace += " ";
}
else
{
break;
}
}
strSpace += " ";
// Hashtable 时
if (classType.Name == "Hashtable")
{
Hashtable ht = (Hashtable)argDataObject;
System.Collections.IEnumerator keyEnum = ht.Keys.GetEnumerator();
int count = ht.Count;
keyEnum.Reset();
strMessage = argDataName + "----------------------";
WriteLogFile(argLoglevel, argFqcn, argMethodName, strMessage, null);
for (int i = 0; i < count; i++)
{
keyEnum.MoveNext();
object hashKey = keyEnum.Current; // Key
object hashValue = ht[hashKey]; // Value
WriteDataLog(argLoglevel, argFqcn, argMethodName, strSpace + hashKey.ToString(), hashValue);
}
return;
}
// ArrayList时
if (classType.Name == "ArrayList")
{
ArrayList at = (ArrayList)argDataObject;
int count = at.Count;
strMessage = argDataName + "----------------------";
WriteLogFile(argLoglevel, argFqcn, argMethodName, strMessage, null);
for (int i = 0; i < count; i++)
{
WriteDataLog(argLoglevel, argFqcn, argMethodName, strSpace + "[" + i.ToString() + "]", at[i].ToString());
}
return;
}
// DataSet时
if (classType.Name == "DataSet" || classType.BaseType.Name == "DataSet")
{
strMessage = argDataName + "----------------------";
WriteLogFile(argLoglevel, argFqcn, argMethodName, strMessage, null);
foreach (DataTable myDataTable in ((DataSet)argDataObject).Tables)
{
strMessage = strSpace + "Table名：" + "\t" + "[" + myDataTable.TableName + "]";
WriteLogFile(argLoglevel, argFqcn, argMethodName, strMessage, null);
int intCurrentRow = 0;
foreach (DataRow myRow in myDataTable.Rows)
{
foreach (DataColumn myColumn in myDataTable.Columns)
{
WriteDataLog(argLoglevel, argFqcn, argMethodName, strSpace + myColumn.ColumnName + "[" + intCurrentRow.ToString() + "]", myRow[myColumn]);
}
intCurrentRow++;
}
}
return;
}
// DataTable时
if (classType.Name == "DataTable" || classType.BaseType.Name == "DataTable")
{
strMessage = argDataName + "----------------------";
WriteLogFile(argLoglevel, argFqcn, argMethodName, strMessage, null);
DataTable myDataTable = (DataTable)argDataObject;
strMessage = strSpace + "Table名：" + "\t" + "[" + myDataTable.TableName + "]";
WriteLogFile(argLoglevel, argFqcn, argMethodName, strMessage, null);
int intCurrentRow = 0;
foreach (DataRow myRow in myDataTable.Rows)
{
foreach (DataColumn myColumn in myDataTable.Columns)
{
WriteDataLog(argLoglevel, argFqcn, argMethodName, strSpace + myColumn.ColumnName + "[" + intCurrentRow.ToString() + "]", myRow[myColumn]);
}
intCurrentRow++;
}
return;
}
// 基本型、array、Hashtable以外时
strMessage = argDataName + "----------------------";
WriteLogFile(argLoglevel, argFqcn, argMethodName, strMessage, null);
System.Reflection.PropertyInfo[] pi = classType.GetProperties();
System.Reflection.MemberInfo[] classMembInfo = classType.GetMembers();
System.Reflection.FieldInfo[] classFieldInfo = classType.GetFields();
System.Reflection.ConstructorInfo[] classConstInfo = classType.GetConstructors();
// 各属性输出
foreach (System.Reflection.PropertyInfo tpi in pi)
{
if (tpi.GetValue(argDataObject, null) == null)
{
strMessage = strSpace + tpi.Name + "\t" + "[" + tpi.PropertyType.Name + "]";
strMessage += "\t" + "NULL";
WriteLogFile(argLoglevel, argFqcn, argMethodName, strMessage, null);
}
else
{
WriteDataLog(argLoglevel, argFqcn, argMethodName, strSpace + tpi.Name, tpi.GetValue(argDataObject, null));
}
}
#endregion
}
public TraceLoggerFactory(LogLevelEnum defaultMinimumLogLevel, IFullyQualifiedName defaultLoggerSource)
{
_defaultMinimumLogLevel = defaultMinimumLogLevel;
_defaultLoggerSource = defaultLoggerSource;
}
public void Log(LogLevelEnum level, Exception ex, string message, params object[] args)
{
Log(level, Utils.Format(Utils.Format("{0}{1}{2}", Utils.Format(ex), Environment.NewLine, message), args));
}
