Shulou(Shulou.com)06/02 Report--

This article is to share with you about the use of log4net in C #. The editor thinks it is very practical, so share it with you as a reference and follow the editor to have a look.

Log4net is a third-party open source component, the main purpose of which is to combine and generate log information, while saving the configuration to various storage media or presentation platforms. In actual projects, Log4net can save the operation of the system and view the status of the system at that time according to the saved log information when an exception occurs in the system.

Advantages of 1.Log4net:

Almost all large applications have their own API for tracking and debugging. Because once the program is deployed, it is no longer possible to use specialized debugging tools. However, an administrator may need to have a powerful logging system to diagnose and fix configuration problems.

Experience has shown that logging is often an important part of the software development cycle. It has the following advantages: it can provide a precise environment for developers to find the Bug; in the application as soon as possible. Once the Log output code is added to the program, log information can be generated and output during the program running without human intervention. In addition, the log information can be output to different places (console, files, etc.) for future research.

Log4net is designed for this purpose as a logging package for the .NET development environment.

2 installation of Log4net:

Users can download the source code of log4net from http://logging.apache.org/log4net/. After unzipping the package, load log4net.sln into Visual Studio .NET in the unzipped src directory, and you can get log4net.dll after compilation. To add logging to your program, users only need to introduce log4net.dll into the project.

3 structure of Log4net

Log4net has four main components, namely Logger (logger), Repository (library), Appender (attachment) and Layout (layout).

(1) Logger interface

Logger is the main component that the application needs to interact with, and it is used to generate log messages. The resulting log messages are not displayed directly and are not output until they are formatted by Layout in advance.

Logger provides a variety of ways to log a message, you can create multiple Logger in your application, and each instantiated Logger object is maintained by the log4net framework as a named entity (named entity). This means that in order to reuse a Logger object, you don't have to pass it between different classes or objects, you just need to call it with its name as an argument. The log4net framework uses an inheritance system, which is similar to namespaces in .NET. That is, if there are two logger, which are defined as a.b.c and A.B, then we say that A.B is the ancestor of a.b.c. Each logger inherits the attributes of its ancestors

The Log4net framework defines an ILog interface that all logger classes must implement. If you want to implement a custom logger, you must first implement this interface. You can refer to several examples in the / extension directory.

The definition of ILog interface is as follows:

Public interface ILog {void Debug (object message); void Info (object message); void Warn (object message); void Error (object message); void Fatal (object message); / / each of the above methods has an overloaded method to support exception handling. / / each overloaded method is shown below, with an additional parameter of the exception type. The void Debug (object message, Exception ex); / /... / Boolean attribute is used to check the log level of Logger / / (we'll see the log level later) bool isDebugEnabled; bool isInfoEnabled; / /... Boolean attribute corresponding to other methods}

The Log4net framework defines a class called LogManager that manages all logger objects. It has a GetLogger () static method that uses the name parameter we provide to retrieve the existing Logger object. If the Logger object does not exist in the framework, it will also create a Logger object for us. The code is as follows:

Log4net.ILog log = log4net.LogManager.GetLogger ("logger-name")

Typically, we call GetLogger () with the type of the class (class) as an argument to keep track of the class we are logging. The type of the passed class (class) can be obtained using the typeof (Classname) method, or it can be obtained using the following reflection method:

System.Reflection.MethodBase.GetCurrentMethod () DeclaringType

Although the symbol is a little longer, the latter can be used in some situations, such as getting the type (type) of the class (class) that calls the method.

(2) level of log

As you can see in the ILog interface, there are five different ways to track an application. In fact, these five methods operate on different logging priorities set by the Logger object. These different levels are defined as constants in the log4net.spi.Level class. You can use any method in the program. But in the release of * * you may not want all the code to waste your CPU cycle, so the framework provides seven levels and corresponding Boolean attributes to control the type of logging.

There are several values for Level:

Table 1 Log level of Logger

In the log4net framework, each log object is assigned a log priority by setting the configuration file. If a log object is not explicitly assigned a level, the object attempts to inherit a level value from its ancestors.

Each method of the ILog interface has a predefined level value. As you can see in Table 1, the Inof () method of ILog has an INFO level. Again, and so on, the Error () method has an ERROR level. When we use any of the above methods, the log4net framework checks the level of the log object logger and the level of the method. Log requests are accepted and executed only if the level of the method is higher than the log level.

For example, when you create a log object and set its level to INFO. So the framework sets each Boolean property of the log. When you call the corresponding logging method, the framework checks the corresponding Boolean property to determine whether the method can be executed. The code is as follows:

Logger.Info ("message"); Logger.Debug ("message"); Logger.Warn ("message")

For the * method, the level of Info () is equal to that of the log (INFO), so the log request is passed and we can get the output "message".

For the second method, the level of Debug () is lower than the log level (INFO) of the log object logger, so the log request is rejected and we don't get any output. Similarly, for the third line of statements, we can easily draw a conclusion.

There are two special levels in Table 1: ALL and OFF. ALL means that all log requests are allowed. OFF is denying all requests.

You can also explicitly check the Boolean property of the Logger object, as follows:

If (logger.IsDebugEnabled) {Logger.Debug ("message");}

Repository

Repository is mainly used to maintain the organizational structure of log objects. In previous versions of log4net, the framework only supported hierarchical organizational structures (hierarchical organization). This hierarchical structure is essentially an implementation of the library and is defined in the log4net.Repository.Hierarchy namespace. To implement a Repository, you need to implement the log4net.Repository.ILoggerRepository interface. However, this interface is not usually implemented directly, but is inherited from the log4net.Repository.LoggerRepositorySkeleton base class. System libraries (hierarchical repository) are implemented by the log4net.Repository.Hierarchy.Hierarchy class.

If you are a user of the log4net framework, not an extender, you will hardly use Repository classes in your code. Instead, you need to use the LogManager class to automate the management of libraries and log objects.

Appender

A good logging framework should be able to produce multi-destination output. For example, output to the console or save to a log file. Log4net can meet these requirements very well. It uses a component called Appender to define the output medium. As the name suggests, these components attach them to the Logger logging component and pass the output to the output stream. You can attach multiple Appender components to a log object. The Log4net framework provides several Appender components. A complete list of the Appender components provided by log4net can be found in the help manual of the log4net framework. With these off-the-shelf Appender components, you don't have to write them yourself in general. But if you like, you can inherit from the log4net.Appender.AppenderSkeleton class

Appender Filters

An Appender object passes all log events to the output stream by default. Appender's filter (Appender Filters) can filter log events by different criteria. There are already several predefined filters under the log4net.Filter namespace. Using these filters, you can filter log events by log level range, or by a particular string.

Thank you for reading! This is the end of this article on "what is the use of log4net in C#". I hope the above content can be of some help to you, so that you can learn more knowledge. if you think the article is good, you can share it for more people to see!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.