[转载]非常完善的Log4net详细说明

usingSystem;
usingSystem.Collections.Generic;
usingSystem.Linq;
usingSystem.Text;
usinglog4net.Layout;
usinglog4net.Layout.Pattern;
usingSystem.Reflection;
usingSystem.Collections;
usingFastReflectionLib;

namespaceTGLog.ExpandLayout2
{
    public classReflectionLayout : PatternLayout
    {
        publicReflectionLayout()
        {
            this.AddConverter("property", typeof(ReflectionPatternConverter));
        }
    }
    public classReflectionPatternConverter : PatternLayoutConverter
    {
        protected override voidConvert(System.IO.TextWriter writer,log4net.Core.LoggingEvent loggingEvent)
        {
            if (Option != null)
            {
                //写入指定键的值
WriteObject(
                    writer,
                    loggingEvent.Repository,
                    LookupProperty(Option,loggingEvent)
                    );
            }
            else{
                //写入所有关键值对
WriteDictionary(
                    writer,
                    loggingEvent.Repository,
                    loggingEvent.GetProperties()
                    );
            }
        }
        /// <summary>
        ///通过反射获取传入的日志对象的某个属性的值
        /// </summary>
        /// <param name="property"></param>
        /// <returns></returns>
        private object LookupProperty(stringproperty,log4net.Core.LoggingEvent loggingEvent)
        {
            object propertyValue = string.Empty;

            PropertyInfo propertyInfo =loggingEvent.MessageObject.GetType().GetProperty(property);

            if (propertyInfo != null)
            {
                propertyValue =propertyInfo.GetValue(loggingEvent.MessageObject, null);

            }
            returnpropertyValue;
        }
    }
}

usingSystem;

usingSystem.Collections.Generic;

usingSystem.Linq;

usingSystem.Text;

usinglog4net.Core;

 

namespaceTGLog.ExpandILog

{

    public classMyLogImpl : LogImpl, IMyLog

    {

        /// <summary>

        ///The fully qualified name of this declaring type not the type of any subclass.

        /// </summary>

        private readonly static Type ThisDeclaringType = typeof(MyLogImpl);

 

        publicMyLogImpl(ILogger logger)

            : base(logger)

        {       

        }

 

        #region Implementation of IMyLog

 

        public void Debug(int operatorID, string operand, int actionType,objectmessage,

 string ip, string browser, stringmachineName)

        {

            Debug(operatorID,  operand,  actionType, message,

  ip,  browser, machineName, null);

        }

 

        public void Debug(int operatorID, string operand, int actionType,objectmessage,

string ip, string browser, stringmachineName, System.Exception t)

        {

            if (this.IsDebugEnabled)

            {

                LoggingEvent loggingEvent =

newLoggingEvent(ThisDeclaringType, Logger.Repository,

                                       Logger.Name, Level.Info, message, t);

                loggingEvent.Properties["Operator"] =operatorID;

                loggingEvent.Properties["Operand"] =operand;

                loggingEvent.Properties["ActionType"] =actionType;

                loggingEvent.Properties["IP"] =ip;

                loggingEvent.Properties["Browser"] =browser;

                loggingEvent.Properties["MachineName"] =machineName;

                Logger.Log(loggingEvent);

            }

        }

 

        public void Info(int operatorID, string operand, int actionType, objectmessage,

string ip, string browser, stringmachineName)

        {

            Info(operatorID, operand, actionType, message, ip, browser, machineName, null);

        }

 

        public void Info(int operatorID, string operand, int actionType, objectmessage,

 string ip, string browser, stringmachineName, System.Exception t)

        {

            if (this.IsInfoEnabled)

            {

                LoggingEvent loggingEvent =

 newLoggingEvent(ThisDeclaringType, Logger.Repository,

 Logger.Name, Level.Info, message, t);

                loggingEvent.Properties["Operator"] =operatorID;

                loggingEvent.Properties["Operand"] =operand;

                loggingEvent.Properties["ActionType"] =actionType;

                loggingEvent.Properties["IP"] =ip;

                loggingEvent.Properties["Browser"] =browser;

                loggingEvent.Properties["MachineName"] =machineName;

                Logger.Log(loggingEvent);

            }

        }

 

        public void Warn(int operatorID, string operand, int actionType, objectmessage,

string ip, string browser, stringmachineName)

        {

            Warn(operatorID, operand, actionType, message, ip, browser, machineName, null);

        }

 

        public void Warn(int operatorID, string operand, int actionType, objectmessage,

 string ip, string browser, stringmachineName, System.Exception t)

        {

            if (this.IsWarnEnabled)

            {

                LoggingEvent loggingEvent =

 newLoggingEvent(ThisDeclaringType, Logger.Repository,

Logger.Name, Level.Info, message, t);

                loggingEvent.Properties["Operator"] =operatorID;

                loggingEvent.Properties["Operand"] =operand;

                loggingEvent.Properties["ActionType"] =actionType;

                loggingEvent.Properties["IP"] =ip;

                loggingEvent.Properties["Browser"] =browser;

                loggingEvent.Properties["MachineName"] =machineName;

                Logger.Log(loggingEvent);

            }

        }

 

        public void Error(int operatorID, string operand, int actionType, objectmessage,

string ip, string browser, stringmachineName)

        {

            Error(operatorID, operand, actionType, message, ip, browser, machineName, null);

        }

 

        public void Error(int operatorID, string operand, int actionType, objectmessage,

 string ip, string browser, stringmachineName, System.Exception t)

        {

            if (this.IsErrorEnabled)

            {

                LoggingEvent loggingEvent =

 newLoggingEvent(ThisDeclaringType, Logger.Repository,

 Logger.Name, Level.Info, message, t);

                loggingEvent.Properties["Operator"] =operatorID;

                loggingEvent.Properties["Operand"] =operand;

                loggingEvent.Properties["ActionType"] =actionType;

                loggingEvent.Properties["IP"] =ip;

                loggingEvent.Properties["Browser"] =browser;

                loggingEvent.Properties["MachineName"] =machineName;

                Logger.Log(loggingEvent);

            }

        }

 

        public void Fatal(int operatorID, string operand, int actionType, objectmessage,

 string ip, string browser, stringmachineName)

        {

            Fatal(operatorID, operand, actionType, message, ip, browser, machineName, null);

        }

 

        public void Fatal(int operatorID, string operand, int actionType, objectmessage,

 string ip, string browser, stringmachineName, System.Exception t)

        {

            if (this.IsFatalEnabled)

            {

                LoggingEvent loggingEvent =

 newLoggingEvent(ThisDeclaringType, Logger.Repository,

                                       Logger.Name, Level.Info, message, t);

                loggingEvent.Properties["Operator"] =operatorID;

                loggingEvent.Properties["Operand"] =operand;

                loggingEvent.Properties["ActionType"] =actionType;

                loggingEvent.Properties["IP"] =ip;

                loggingEvent.Properties["Browser"] =browser;

                loggingEvent.Properties["MachineName"] =machineName;

                Logger.Log(loggingEvent);

            }

        }

        #endregion Implementation of IMyLog
    }

}

#region Copyright & License

//

//Copyright 2001-2005 The Apache Software Foundation

//

//Licensed under the Apache License, Version 2.0 (the "License");

//you may not use this file except in compliance with the License.

//You may obtain a copy of the License at

//

// http://www.apache.org/licenses/LICENSE-2.0

//

//Unless required by applicable law or agreed to in writing, software

//distributed under the License is distributed on an "AS IS" BASIS,

//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

//See the License for the specific language governing permissions and

//limitations under the License.

//

#endregion

 

usingSystem;

usingSystem.Reflection;

usingSystem.Collections;

usinglog4net;

usinglog4net.Core;

usinglog4net.Repository;

usinglog4net.Repository.Hierarchy;

 

namespaceTGLog.ExpandILog

{

    public classMyLogManager

    {

        #region Static Member Variables

 

        /// <summary>

        ///The wrapper map to use to hold the <see cref="EventIDLogImpl"/>objects

        /// </summary>

        private static readonly WrapperMap s_wrapperMap = newWrapperMap(newWrapperCreationHandler(WrapperCreationHandler));

 

        #endregion

 

        #region Constructor

 

        /// <summary>

        ///Private constructor to prevent object creation

        /// </summary>

        privateMyLogManager() { }

 

        #endregion

 

        #region Type Specific Manager Methods

 

        /// <summary>

        ///Returns the named logger if it exists

        /// </summary>

        /// <remarks>

        /// <para>If the named logger exists (in the default hierarchy) then it

        ///returns a reference to the logger, otherwise it returns

        /// <c>null</c>.</para>

        /// </remarks>

        /// <param name="name">The fully qualified logger name to look for</param>

        /// <returns>The logger found, or null</returns>

        public static IMyLog Exists(stringname)

        {

            returnExists(Assembly.GetCallingAssembly(), name);

        }

 

        /// <summary>

        ///Returns the named logger if it exists

        /// </summary>

        /// <remarks>

        /// <para>If the named logger exists (in the specified domain) then it

        ///returns a reference to the logger, otherwise it returns

        /// <c>null</c>.</para>

        /// </remarks>

        /// <param name="domain">the domain to lookup in</param>

        /// <param name="name">The fully qualified logger name to look for</param>

        /// <returns>The logger found, or null</returns>

        public static IMyLog Exists(string domain, stringname)

        {

            returnWrapLogger(LoggerManager.Exists(domain, name));

        }

 

        /// <summary>

        ///Returns the named logger if it exists

        /// </summary>

        /// <remarks>

        /// <para>If the named logger exists (in the specified assembly's domain) then it

        ///returns a reference to the logger, otherwise it returns

        /// <c>null</c>.</para>

        /// </remarks>

        /// <param name="assembly">the assembly to use to lookup the domain</param>

        /// <param name="name">The fully qualified logger name to look for</param>

        /// <returns>The logger found, or null</returns>

        public static IMyLog Exists(Assembly assembly, stringname)

        {

            returnWrapLogger(LoggerManager.Exists(assembly, name));

        }

 

        /// <summary>

        ///Returns all the currently defined loggers in the default domain.

        /// </summary>

        /// <remarks>

        /// <para>The root logger is <b>not</b>included in the returned array.</para>

        /// </remarks>

        /// <returns>All the defined loggers</returns>

        public staticIMyLog[] GetCurrentLoggers()

        {

            returnGetCurrentLoggers(Assembly.GetCallingAssembly());

        }

 

        /// <summary>

        ///Returns all the currently defined loggers in the specified domain.

        /// </summary>

        /// <param name="domain">the domain to lookup in</param>

        /// <remarks>

        ///The root logger is <b>not</b>included in the returned array.

        /// </remarks>

        /// <returns>All the defined loggers</returns>

        public static IMyLog[] GetCurrentLoggers(stringdomain)

        {

            returnWrapLoggers(LoggerManager.GetCurrentLoggers(domain));

        }

 

        /// <summary>

        ///Returns all the currently defined loggers in the specified assembly's domain.

        /// </summary>

        /// <param name="assembly">the assembly to use to lookup the domain</param>

        /// <remarks>

        ///The root logger is <b>not</b>included in the returned array.

        /// </remarks>

        /// <returns>All the defined loggers</returns>

        public staticIMyLog[] GetCurrentLoggers(Assembly assembly)

        {

            returnWrapLoggers(LoggerManager.GetCurrentLoggers(assembly));

        }

 

        /// <summary>

        ///Retrieve or create a named logger.

        /// </summary>

        /// <remarks>

        /// <para>Retrieve a logger named as the <paramref name="name"/>

        ///parameter. If the named logger already exists, then the

        ///existing instance will be returned. Otherwise, a new instance is

        ///created.</para>

        ///

        /// <para>By default, loggers do not have a set level but inherit

        ///it from the hierarchy. This is one of the central features of

        ///log4net.</para>

        /// </remarks>

        /// <param name="name">The name of the logger to retrieve.</param>

        /// <returns>the logger with the name specified</returns>

        public static IMyLog GetLogger(stringname)

        {

            returnGetLogger(Assembly.GetCallingAssembly(), name);

        }

 

        /// <summary>

        ///Retrieve or create a named logger.

        /// </summary>

        /// <remarks>

        /// <para>Retrieve a logger named as the <paramref name="name"/>

        ///parameter. If the named logger already exists, then the

        ///existing instance will be returned. Otherwise, a new instance is

        ///created.</para>

        ///

        /// <para>By default, loggers do not have a set level but inherit

        ///it from the hierarchy. This is one of the central features of

        ///log4net.</para>

        /// </remarks>

        /// <param name="domain">the domain to lookup in</param>

        /// <param name="name">The name of the logger to retrieve.</param>

        /// <returns>the logger with the name specified</returns>

        public static IMyLog GetLogger(string domain, stringname)

        {

            returnWrapLogger(LoggerManager.GetLogger(domain, name));

        }

 

        /// <summary>

        ///Retrieve or create a named logger.

        /// </summary>

        /// <remarks>

        /// <para>Retrieve a logger named as the <paramref name="name"/>

        ///parameter. If the named logger already exists, then the

        ///existing instance will be returned. Otherwise, a new instance is

        ///created.</para>

        ///

        /// <para>By default, loggers do not have a set level but inherit

        ///it from the hierarchy. This is one of the central features of

        ///log4net.</para>

        /// </remarks>

        /// <param name="assembly">the assembly to use to lookup the domain</param>

        /// <param name="name">The name of the logger to retrieve.</param>

        /// <returns>the logger with the name specified</returns>

        public static IMyLog GetLogger(Assembly assembly, stringname)

        {

            returnWrapLogger(LoggerManager.GetLogger(assembly, name));

        }

 

        /// <summary>

        ///Shorthand for <see cref="LogManager.GetLogger(string)"/>.

        /// </summary>

        /// <remarks>

        ///Get the logger for the fully qualified name of the type specified.

        /// </remarks>

        /// <param name="type">The full name of <paramref name="type"/>will

        ///be used as the name of the logger to retrieve.</param>

        /// <returns>the logger with the name specified</returns>

        public staticIMyLog GetLogger(Type type)

        {

            returnGetLogger(Assembly.GetCallingAssembly(), type.FullName);

        }

 

        /// <summary>

        ///Shorthand for <see cref="LogManager.GetLogger(string)"/>.

        /// </summary>

        /// <remarks>

        ///Get the logger for the fully qualified name of the type specified.

        /// </remarks>

        /// <param name="domain">the domain to lookup in</param>

        /// <param name="type">The full name of <paramref name="type"/>will

        ///be used as the name of the logger to retrieve.</param>

        /// <returns>the logger with the name specified</returns>

        public static IMyLog GetLogger(stringdomain, Type type)

        {

            returnWrapLogger(LoggerManager.GetLogger(domain, type));

        }

 

        /// <summary>

        ///Shorthand for <see cref="LogManager.GetLogger(string)"/>.

        /// </summary>

        /// <remarks>

        ///Get the logger for the fully qualified name of the type specified.

        /// </remarks>

        /// <param name="assembly">the assembly to use to lookup the domain</param>

        /// <param name="type">The full name of <paramref name="type"/>will

        ///be used as the name of the logger to retrieve.</param>

        /// <returns>the logger with the name specified</returns>

        public staticIMyLog GetLogger(Assembly assembly, Type type)

        {

            returnWrapLogger(LoggerManager.GetLogger(assembly, type));

        }

 

        #endregion

 

        #region Extension Handlers

 

        /// <summary>

        ///Lookup the wrapper object for the logger specified

        /// </summary>

        /// <param name="logger">the logger to get the wrapper for</param>

        /// <returns>the wrapper for the logger specified</returns>

        private staticIMyLog WrapLogger(ILogger logger)

        {

            return(IMyLog)s_wrapperMap.GetWrapper(logger);

        }

 

        /// <summary>

        ///Lookup the wrapper objects for the loggers specified

        /// </summary>

        /// <param name="loggers">the loggers to get the wrappers for</param>

        /// <returns>Lookup the wrapper objects for the loggers specified</returns>

        private staticIMyLog[] WrapLoggers(ILogger[] loggers)

        {

            IMyLog[] results = newIMyLog[loggers.Length];

            for (int i = 0; i < loggers.Length; i++)

            {

                results[i] =WrapLogger(loggers[i]);

            }

            returnresults;

        }

 

        /// <summary>

        ///Method to create the <see cref="ILoggerWrapper"/>objects used by

        ///this manager.

        /// </summary>

        /// <param name="logger">The logger to wrap</param>

        /// <returns>The wrapper for the logger specified</returns>

        private staticILoggerWrapper WrapperCreationHandler(ILogger logger)

        {

            return newMyLogImpl(logger);

        }

        #endregion
    }

}

usingSystem;

usingSystem.Collections.Generic;

usingSystem.Linq;

usingSystem.Text;

usinglog4net;

 

namespaceTGLog.ExpandILog

{

    public interfaceIMyLog : ILog

    {

        void Debug(int operatorID, string operand, int actionType, objectmessage,

string ip, string browser, stringmachineName);

        void Debug(int operatorID, string operand, int actionType,objectmessage,

string ip, string browser, stringmachineName, Exception t);

 

        void Info(int operatorID, string operand, int actionType, objectmessage,

string ip, string browser, stringmachineName);

        void Info(int operatorID, string operand, int actionType, objectmessage,

string ip, string browser, stringmachineName, Exception t);

 

        void Warn(int operatorID, string operand, int actionType, objectmessage,

string ip, string browser, stringmachineName);

        void Warn(int operatorID, string operand, int actionType, objectmessage,

 string ip, string browser, stringmachineName, Exception t);

 

        void Error(int operatorID, string operand, int actionType, objectmessage,

string ip, string browser, stringmachineName);

        void Error(int operatorID, string operand, int actionType, objectmessage,

string ip, string browser, stringmachineName, Exception t);

 

        void Fatal(int operatorID, string operand, int actionType, objectmessage,

string ip, string browser, stringmachineName);

        void Fatal(int operatorID, string operand, int actionType, objectmessage,

string ip, string browser, stringmachineName, Exception t);

    }

}