Log4net的简单扩展

最新推荐文章于 2019-06-09 22:39:00 发布
最新推荐文章于 2019-06-09 22:39:00 发布
阅读量2.6k 收藏 2
点赞数 1
分类专栏： web 文章标签： log4net 扩展
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zaichuanguanshui/article/details/51985364
版权

一、通过重写布局Layout输出传入的 message对象的属性

1、重写Layout类

通过继承log4net.Layout.PatternLayout类，使用log4net.Core.LoggingEvent类的方法得到了要输出的message类的名称，然后通过反射得到各个属性的值，使用PatternLayout类AddConverter方法传入得到的值。

2、配置相应的配置文件

配置文件其他地方不用改动，只是需要改动中的。例如：

<layout type="TGLog.ExpandLayout2.ReflectionLayout,TGLog">
    <param name="ConversionPattern" value="记录时间：%date    操作者ID：%property{Operator}操作类型：%property{Action}%n  消息描述：%property{Message}%n异常：%exception%n " />
</layout>

其中layout的type由原来的log4net.Layout.PatternLayout换为自定义的TGLog.ExpandLayout2.ReflectionLayout（TGLog.ExpandLayout2为命名空间）。%property{Operator}输出的即为message类对象的属性Operator的值。数据库配置同样，相应的字段如果是自定义的，则输出选用自定义的layout。例：

<!--动作类型-->
<parameter>
    <parameterName value="@action_type" />
    <dbType value="Int16" />
    <layout type="TGLog.ExpandLayout2.ReflectionLayout,TGLog">
        <conversionPattern value="%property{ActionType}" />
    </layout>
</parameter>

3、程序中如何使用

和一般使用方法基本相同，只是传入的参数是一个自定义的类，类的属性和配置文件中所有的%property{属性}是一致的，即%property{属性}在输出的时候就查找传入message类中有无对应的属性，如果有就输出值，没有则输出null。例：

log4net.ILog log =log4net.LogManager.GetLogger("ReflectionLayout");
try
{
    log.Debug(new LogMessage(1,"操作对象：0",(int)TGLog.ActionType.Other,"这是四个参数测试"));
}
catch(Exception ec)
{
    log.Error(new LogMessage(1,"操作对象：0",(int)TGLog.ActionType.Other,"这是全部参数测试","192.168.1.1","MyComputer","Maxthon(MyIE2)Fans"),ec);
}

LogMessage的全部属性的构造方法如下：

public LogMessage(
    int operatorID,
    string operand,
    int ActionType,
    string message,
    string ip,
    string machineName,
    string browser)
{
    this.ActionType = ActionType;
    this.Operator = operatorID;
    this.Message = message;
    this.Operand = operand;
    this.IP = ip;
    this.Browser = browser;
    this.MachineName = machineName;
}

二、通过重新实现ILog接口来增加输入的参数

1、重写LogImpl，LogManager类及实现ILog接口

这种方式是通过构造一个名为IMyLog接口，是继承Ilog接口而来，然后分别在MyLogImpl，MyLogManager重新实现IMyLog接口，增加了每种方法的参数。MyLogImpl，MyLogManager分别继承LogImpl，LogManager而来。

代码分别见4.1、4.2、4.3：

2、配置相应的配置文件

配置文件其他地方不用改动，只是需要改动appender中的layout元素name为ConversionPattern的value中输出格式。例如：

<layout type=" log4net.Layout.PatternLayout ">
    <param name="ConversionPattern" value="记录时间：%date    操作者ID：%property{Operator}操作类型：%property{Action}%n  消息描述：%property{Message}%n异常：%exception%n " />
</layout>

%property{参数}中的参数在MyLogImpl类中定义，如语句：

loggingEvent.Properties[“Operator”] = operatorID;

就定义了Operator输出参数，即%property{Operator}输出的即为IMyLog中的参数operatorID的值。

数据库配置同样。例：

<!--动作类型-->
<parameter>
    <parameterName value="@action_type" />
    <dbType value="Int16" />
    <layout type=" log4net.Layout.PatternLayout ">
        <conversionPattern value="%property{ActionType}" />
    </layout>
</parameter>

3、程序中如何使用

先引用IMyLog ，MyLogManager所在的命名空间，创建一个IMyLog对象，myLog的5 个方法，每个方法都有四个重载，增加了多参数的重载。例：

IMyLog myLog = MyLogManager.GetLogger("ExpandILog");
try
{
    myLog.Debug("这是一个参数重载测试!");          
}
catch(Exception ec)
{
    log.Error(1,"操作对象：0",(int)TGLog.ActionType.Other,"这是全部参数测试","192.168.1.1","MyComputer","Maxthon(MyIE2)Fans",ec);
}

4、附录

4.1MyLogImpl类代码

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using log4net.Core;

namespace TGLog.ExpandILog
{
    public class MyLogImpl : 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);
    public MyLogImpl(ILogger logger): base(logger)
    {       

    }
    #region Implementation of IMyLog
    public void Debug(int operatorID, string operand, int actionType,object message,string ip, string browser, string machineName)
    {
        Debug(operatorID,  operand,  actionType, message,ip,  browser, machineName, null);
    }
    public void Debug(int operatorID, string operand, int actionType,object message,string ip, string browser, string machineName, System.Exception t)
    {
        if (this.IsDebugEnabled)
        {
            LoggingEvent loggingEvent =new LoggingEvent(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, object message,string ip, string browser, string machineName)
    {
        Info(operatorID, operand, actionType, message, ip, browser, machineName, null);
    }
    public void Info(int operatorID, string operand, int actionType, object message,string ip, string browser, string machineName, System.Exception t)
    {
        if (this.IsInfoEnabled)
        {
            LoggingEvent loggingEvent =new LoggingEvent(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, object message,string ip, string browser, string machineName)
    {
        Warn(operatorID, operand, actionType, message, ip, browser, machineName, null);
    }
    public void Warn(int operatorID, string operand, int actionType, object message,string ip, string browser, string machineName, System.Exception t)
    {
        if (this.IsWarnEnabled)
        {
            LoggingEvent loggingEvent =new LoggingEvent(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, object message,string ip, string browser, string machineName)
        {
            Error(operatorID, operand, actionType, message, ip, browser, machineName, null);
        }public void Error(int operatorID, string operand, int actionType, object message,string ip, string browser, string machineName, System.Exception t)
        {
            if (this.IsErrorEnabled)
            {
                LoggingEvent loggingEvent =new LoggingEvent(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, object message,string ip, string browser, string machineName)
        {
            Fatal(operatorID, operand, actionType, message, ip, browser, machineName, null);
        }
        public void Fatal(int operatorID, string operand, int actionType, object message,string ip, string browser, string machineName, System.Exception t)
        {
            if (this.IsFatalEnabled)
            {
                LoggingEvent loggingEvent =new LoggingEvent(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
    }
}

4.2 MyLogManager类代码

using System;
using System.Reflection;
using System.Collections;
using log4net;
using log4net.Core;
using log4net.Repository;
using log4net.Repository.Hierarchy;

namespace TGLog.ExpandILog
{
    public class MyLogManager
    {
        #region Static Member Variables
        /// <summary>
        /// The wrapper map to use to hold the <see cref="EventIDLogImpl"/> objects
        /// </summary>
        private static readonly WrapperMap s_wrapperMap = new WrapperMap(new WrapperCreationHandler(WrapperCreationHandler));
        #endregion

        #region Constructor
        /// <summary>
        /// Private constructor to prevent object creation
        /// </summary>
        private MyLogManager() { }
        #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(string name)
        {
            return Exists(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, string name)
        {
            return WrapLogger(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, string name)
        {
            return WrapLogger(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 static IMyLog[] GetCurrentLoggers()
        {
        return GetCurrentLoggers(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(string domain)
        {
            return WrapLoggers(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 static IMyLog[] GetCurrentLoggers(Assembly assembly)
        {
            return WrapLoggers(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(string name)
        {
            return GetLogger(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, string name)
        {
            return WrapLogger(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, string name)
        {
            return WrapLogger(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 static IMyLog GetLogger(Type type)
        {
            return GetLogger(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(string domain, Type type)
        {
            return WrapLogger(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 static IMyLog GetLogger(Assembly assembly, Type type)
        {
            return WrapLogger(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 static IMyLog 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 static IMyLog[] WrapLoggers(ILogger[] loggers)
        {
            IMyLog[] results = new IMyLog[loggers.Length];
            for (int i = 0; i < loggers.Length; i++)
            {
                results[i] = WrapLogger(loggers[i]);
            }
            return results;
        }
        /// <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 static ILoggerWrapper WrapperCreationHandler(ILogger logger)
        {
            return new MyLogImpl(logger);
        }
        #endregion
    }
}

4.3IMyLog类代码

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using log4net;

namespace TGLog.ExpandILog
{
    public interface IMyLog : ILog
    {
        void Debug(int operatorID, string operand, int actionType, object message,string ip, string browser, string machineName);
        void Debug(int operatorID, string operand, int actionType,object message,string ip, string browser, string machineName, Exception t);
        void Info(int operatorID, string operand, int actionType, object message,string ip, string browser, string machineName);
        void Info(int operatorID, string operand, int actionType, object message,string ip, string browser, string machineName, Exception t);
        void Warn(int operatorID, string operand, int actionType, object message,string ip, string browser, string machineName);
        void Warn(int operatorID, string operand, int actionType, object message,string ip, string browser, string machineName, Exception t);
        void Error(int operatorID, string operand, int actionType, object message,string ip, string browser, string machineName);
        void Error(int operatorID, string operand, int actionType, object message,string ip, string browser, string machineName, Exception t);
        void Fatal(int operatorID, string operand, int actionType, object message,string ip, string browser, string machineName);
        void Fatal(int operatorID, string operand, int actionType, object message,string ip, string browser, string machineName, Exception t);
    }
}
zaichuanguanshui
关注
专栏目录
log4net 自定义扩展字段 SQL
01-04
实现log4net的自定义字段扩展 Log4Net中添加自定义日志信息。我们在写日志的时候并不是只写消息（Message）,有些情况需要记录自定义的日志信息等。在Log4Net中增加自定义字段UserName（用户名），Category(类别)这两个字段。 可运行 自行建表 CREATE TABLE [dbo].[Log] ( [Id] [int] IDENTITY (1, 1) NOT NULL , [Date] [datetime] NOT NULL , [Thread] [varchar] (255) NOT NULL , [Level] [varchar] (50) NOT NULL , [Logger] [varchar] (255) NOT NULL , [Message] [varchar] (4000) NOT NULL , [Exception] [varchar] (2000) NULL , [User] [varchar] (50) NULL , [Category] [varchar] (50) NULL )
log4net。log4net
05-22
log4net作为一个强大的日志框架，其灵活性和可扩展性使其在.NET开发中占有一席之地。从最初的1.0版本到4.5，log4net不断适应.NET的发展，提供了更完善的日志解决方案。了解并熟练使用log4net，能够帮助开发者更有效...
Log4net创建日志及简单扩展 收藏
xinfh的专栏
07-01 883
<br />Log4net创建日志及简单扩展 收藏 <br />1、概述<br />log4net是.Net下一个非常优秀的开源日志记录组件。log4net记录日志的功能非常强大。它可以将日志分不同的等级，以不同的格式，输出到不同的媒介。本文主要是介绍如何在Visual Studio2008中使用log4net快速创建系统日志，如何扩展以输出自定义字段。<br />2、一个简单的使用实例<br />第一步：在项目中添加对log4net.dll的引用，这里引用版本是1.2.10.0。<br />第二步：程序启
基于log4net的日志组件扩展封装，实现自动记录交互日志 XYH.Log4Net.Extend（微服务监控）...
oChangJiangHuangHe的博客
06-09 281
背景： 　　随着公司的项目不断的完善，功能越来越复杂，服务也越来越多（微服务），公司迫切需要对整个系统的每一个程序的运行情况进行监控，并且能够实现对自动记录不同服务间的程序调用的交互日志，以及通一个服务或者项目中某一次执行情况的跟踪监控 根据log4net的现有功能满足不了实际需求，所以需要以log4net为基础进行分装完善，现在分装出了一个基础的版本，如有不妥之处，多...
Log4net系列：如何使用Log4net创建日志及简单扩展
行成于思，形之于文
04-01 1317
1、概述 log4net是.Net下一个非常优秀的开源日志记录组件。log4net记录日志的功能非常强大。它可以将日志分不同的等级，以不同的格式，输出到不同的媒介。本文主要是介绍如何在Visual Studio2008中使用log4net快速创建系统日志，如何扩展以输出自定义字段。 2、一个简单的使用实例 第一步：在项目中添加对log4net.dll的引用，这里引用版本是1.2.10.0。
Log4Net笔记（三）Layout使用以及扩展(转)
weixin_30399821的博客
03-08 149
转自：http://www.cnblogs.com/Henllyee/archive/2010/03/06/1679744.html 在上篇文章中介绍几个主要的Appender的配置，本篇文章中介绍下如何编写Layout的配置，以及做些简单的扩展。 Layout组件的作用就是向用户显示格式化的输出信息。一个Appender对象只能有一个Layout对象。其中，我们可以通过继承log4net.L...
log4net-2.0.8-src_log4net源代码_log4net_
10-03
- 插件架构：log4net的输出目标（Appenders）和布局（Layouts）都是可扩展的，用户可以根据需求定制自己的实现。 2. **主要组件** - **Logger**：这是log4net的核心类，负责接收和记录日志事件。每个Logger可以有...
log4net扩展类
06-09
本文将详细介绍如何利用log4net的扩展类，通过反射技术自动获取属性，实现高效、便捷的日志写入功能，并探讨在.NET 3.5环境下兼容log4net的实践。 首先，log4net是一个开源的、跨平台的日志框架，它提供了丰富的...
log4net教程
04-01
通过这个log4net教程，你将能够熟练地在你的VB、C#项目中集成和使用log4net，无论是简单的需求还是复杂的应用场景，都能游刃有余。下载提供的"LogOn.aspx?rp=%2FKB%2Fdotnet%2FLog4...
C# EF Mvc log4net自定义扩展字段，自定义属性
04-18
net ef mvc log4net自定义属性/字段增加，本方法简单易懂，不用做太多的变动，主要利用了log4net.GlobalContext.Properties方法进行，简单实用。 文档漏了一个,commandText的value进行修改，将自定义字段加入
log4net实例
05-25
Log4Net.dll类库，Log4Net.dll使用案例，Log4Net.dll重写相关日志方法，支持自定义属性的日志书写和加密数据库连接字符串，支持文件日志按照月份分文件夹按照日期分文件保存，附Log4Net.dll全配置（对mysql/sql/SQLite/Oracle9i/IBM DB2/Access/windows事件/普通文本等日志的写入配置）。
Log4net实例
09-26
基于C# 。 log4net 的简单例子， 包括存数据库， 包括自定义字段，日志格式，日志路径，等。 部分代码参考了网络上的。
[C#]Log4net创建日志及简单扩展
sinat_32349327的博客
02-22 4020
1、概述 log4net是.Net下一个非常优秀的开源日志记录组件。log4net记录日志的功能非常强大。它可以将日志分不同的等级，以不同的格式，输出到不同的媒介。本文主要是介绍如何在Visual Studio2008中使用log4net快速创建系统日志，如何扩展以输出自定义字段。 2、一个简单的使用实例 第一步：在项目中添加对log4net.dll的引用，这里引用版本是1.2.10
Log4net创建日志及简单扩展
dianjin3567的博客
09-24 123
1、概述 log4net是.Net下一个非常优秀的开源日志记录组件。log4net记录日志的功能非常强大。它可以将日志分不同的等级，以不同的格式，输出到不同的媒介。本文主要是介绍如何在Visual Studio2008中使用log4net快速创建系统日志，如何扩展以输出自定义字段。2、一个简单的使用实例 第一步：在项目中添加对log4net.dll的引用，这里引用版本是1.2.10....
扩展Log4Net框架，灵活运用log4Net
黄翔的专栏
05-02 1440
Log4Net是一款开源的框架，功能比较强大，支持多种方式的日志信息记录，在.NET平台开发，使用Log4Net框架是一个不错的选择，log4Net的使用是非常简单的，需要引用log4Net的dll，然后配置一下配置文件就可以使用了如：在要打印日志的地方LogManager.GetLogger(typeof(Program)).Debug("信息"); 。 注意： 1）Appender：可以将
Log4net 扩展RollingFileAppender
tmaczt的博客
09-13 894
扩展RollingFileAppender实现Error级别的日志发送预警 public class CRollingFileAppender : RollingFileAppender { protected override void Append(log4net.Core.LoggingEvent loggingEvent) { ...
理解Log4Net：安装、结构与配置详解
“Log4Net基础知识，包括安装、结构和配置文件的介绍。” Log4Net是一个广泛使用的开源日志记录框架，适用于.NET环境，由Apache软件基金会开发。...Log4Net的灵活性和可扩展性使得它成为.NET开发者的重要工具。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值