C#中编写系统操作日志的实践

统操作日志在软件开发和运维过程中起着至关重要的作用。通过记录系统在运行时的关键操作和事件，操作日志能帮助开发者监控系统状态、诊断问题、追踪错误，并为系统的安全性和稳定性提供保障。在C#中，我们可以利用多种方法来编写系统操作日志，本文将详细介绍这一过程，并提供实用的示例代码。

一、系统操作日志的重要性

系统操作日志记录了软件或系统在运行时的各种活动，包括但不限于用户登录、数据修改、异常发生等关键事件。这些日志对于后续的故障排查、系统优化、安全审计等方面都具有极高的价值。通过查看和分析日志，开发人员可以快速定位并解决问题，从而提高系统的可靠性和性能。

二、在C#中编写系统操作日志

在C#中，我们可以使用内置的System.Diagnostics命名空间中的Trace和Debug类来记录日志，也可以使用第三方的日志库，如NLog、log4net等。以下是一个使用Trace类的基本示例：

引入命名空间：首先，你需要在代码文件的顶部引入System.Diagnostics命名空间。

using System.Diagnostics;

配置监听器：在应用程序的配置文件（如App.config或Web.config）中，你可以配置Trace类的监听器，以决定将日志信息输出到哪里，比如文件、控制台或Windows事件查看器等。
编写日志：在你的代码中，你可以使用Trace.WriteLine方法来记录日志。

Trace.WriteLine("This is a trace message.");

条件编译：你还可以使用条件编译指令来确保仅在调试期间记录日志。

#if DEBUG
 Trace.WriteLine("Debug message.");
#endif

使用第三方库：对于更复杂的日志需求，如日志级别控制、日志文件分割、异步记录等，你可能需要使用像NLog或log4net这样的第三方库。这些库提供了更丰富的功能和更灵活的配置选项。

三、示例代码

以下是一个简单的示例，展示了如何在C#中使用Trace类记录系统操作日志：

using System;
using System.Diagnostics;

namespace LoggingExample
{
class Program
 {
static void Main(string[] args)
 {
// 配置Trace监听器（通常在配置文件中完成）
 Trace.Listeners.Add(new TextWriterTraceListener("log.txt"));
 Trace.AutoFlush=true;

// 记录操作日志
 Trace.WriteLine("System started at " + DateTime.Now);

// 模拟一些系统操作
 PerformSomeOperation();

// 记录操作完成日志
 Trace.WriteLine("Operation completed successfully.");
 }

static void PerformSomeOperation()
 {
 Trace.WriteLine("Performing some operation...");
// 执行具体操作的代码...
 }
 }
}

在这个示例中，我们创建了一个TextWriterTraceListener来将日志信息写入名为"log.txt"的文件中。然后，在程序的关键点，我们使用Trace.WriteLine方法来记录日志。

四、日志编写的最佳实践

清晰性：确保日志信息清晰明了，能够准确反映系统状态和操作结果。
简洁性：避免在日志中记录过多冗余信息，保持日志的简洁性。
可维护性：使用一致的日志格式和命名规范，便于后续日志的分析和维护。
安全性：确保日志文件的访问权限得到适当控制，防止敏感信息泄露。
性能考虑：对于高性能要求的应用，需要选择合适的日志级别和异步日志记录方式，以减少对系统性能的影响。

Python 项目中，使用打印语句和堆栈跟踪很容易跟踪代码进度和调试。但是，日志记录提供了使用时间戳、文件名、代码行数等进行跟踪和调试的附加功能，区分不同类型的打印语句，甚至可以选择将打印语句保存到日志文件或其他位置，而不是只能在控制台或命令行上查看。

本文将介绍日志记录的组件，如何在文件中执行日志记录，以及如何使用配置以可重用和可扩展的方式跨多个文件执行日志记录。

日志记录的组件

在深入研究代码实现之前，一些组件对于有效使用日志记录是不可或缺的。

日志文件——在哪里记录？

建议将日志保存到日志文件中，而不是在控制台或命令行上查看它们，因为一旦控制台或终端关闭，信息就会消失。我们可以指定要存储日志的项目的相对路径。

您还可以定义保存模式。默认情况下，日志以追加模式保存，但可以更改为写入模式以覆盖以前的日志。

日志级别——何时记录？

根据所跟踪事件的任务和严重性，有 5 种日志记录级别。按照严重程度递增的顺序，

DEBUG：记录详细信息，用于诊断问题，即故障调查
INFO：记录详细信息，在程序正常运行时使用，即状态监控
WARN：记录未来的意外事件或潜在问题，当代码尽管发生意外事件仍能按预期工作时使用
ERROR：记录严重问题，当代码无法执行某些功能时使用
CRITICAL：记录严重错误，在代码无法继续运行时使用

有疑问时，我总是INFO在正常操作时使用水平仪，WARN或者ERROR在遇到小问题和主要问题时使用水平仪。

默认情况下，日志级别为WARN，表示低于该级别的日志级别，即DEBUG和INFO，除非更改默认日志级别，否则不会记录。

日志格式——记录什么？

可以设置日志格式，并将此格式应用于所有日志条目——这意味着您不必手动将相同的格式标准化到每个日志调用！默认情况下，日志条目遵循格式levelname:name:message，例如，DEBUG:root:This is a log entry但可以自定义以包含更多信息，

asctime：日志时间，具有默认格式%Y-%m-%d %H:%M:%S,%f，但可以按照 Python 日期时间模块格式代码进行更改
levelname：日志级别，即DEBUG，，INFO
name：记录器的名称，默认为root
filename: 包含日志调用的文件名，即file.py
module：文件名的名称部分，即file
funcName：包含日志调用的函数名称，即function_name
lineno: 发出日志调用的文件的行号
message: 日志信息，如This is a log entry
更多格式属性可以在这里找到

要指定格式，我们使用"%(component)s"约定，例如"%(levelname)s". 例如，默认格式表示为"%(levelname)s:%(name)s:%(message)s". 这将在下一节中详细说明。

文件中的基本日志记录

在了解了日志记录组件之后，我们准备记录一些信息！日志记录可以这样完成，

import logging
logging.basicConfig(
    filename="output.log",
    filemode="w",
    level=logging.DEBUG,
    format="%(asctime)s:%(levelname)s:%(message)s",
    datefmt="%Y-%m-%d %I:%M:%S%p",
)

logging.debug("Log with debug-level severity")
logging.info("Log with info-level severity")
logging.warning("Log with warning-level severity")
logging.error("Log with error-level severity")
logging.critical("Log with error-level severity")

try:
    raise Exception("Throw exception")
except Exception as e:
    logging.error("Exception occurred", exc_info=True)

在上面的例子中，我们使用basicConfig来指定日志配置，

filename: 日志文件，项目的相对路径
filemode：保存模式，"a"追加（默认），"w"写入
level: 日志级别，DEBUG表示每一项与级别相同或更严重的项目都DEBUG将被记录
format: 日志格式
datefmt:asctime日志格式的日期格式
encoding: 指定编码，仅适用于 Python 3.9 版本

指定配置后，我们可以在代码中插入日志调用等logging.info()来执行日志记录。默认情况下，只会记录日志消息，但我们也可以设置exc_info=True捕获堆栈跟踪，如第 19 行所示。

话虽如此，使用basicConfig实现日志记录需要在不同的文件中定义配置，这会导致重复的代码。在下一节中，我们将使用配置文件以可重用和可扩展的方式实现日志记录。

日志记录的高级组件

对于日志的高级用法，我们可以在配置文件中定义日志配置，使其可重复用于跨多个 Python 文件进行日志记录。如果以这种方式实现日志记录，则可以完成更多项目和自定义，并且它建立在上一节中的基本组件之上。

记录器

记录器公开应用程序代码直接使用的接口

记录器对应name于日志条目中的属性。默认情况下root选择记录器，其设置（例如保存路径、保存模式、格式等）由处理程序处理（下一节）。

使用模块级记录器是一个很好的约定，这样模块名称而不是root将显示为name日志条目的属性。

如果存在需要多个设置的情况，可以定义并使用自定义记录器来代替root记录器。

模块级记录器和自定义记录器可以这样实现，

import logging
logging.basicConfig(...)

logger=logging.getLogger(__name__)

logger=logging.getLogger("custom_logger")

logger.info("Log with info-level severity")

请注意，日志调用现在使用logger.info()而不是logging.info()!

处理程序

处理程序将日志记录发送到适当的目的地（类似于日志文件）

处理程序指定如何保存日志。在前面的部分中，我们仅将日志保存到日志文件中，但还有更多处理日志的方法。这可以通过使用已经为您实现的相关处理程序类来完成。常见的处理程序类包括，

StreamHandler: 将消息发送到流，即控制台
FileHandler: 发送消息到磁盘文件
RotatingFileHandler：支持最大日志文件大小和日志文件轮换的 FileHandler
可以在logging官方文档:https://docs.python.org/3/howto/logging.html#useful-handlers，找到更多处理程序类型。

模块化：处理程序以模块化方式实现，因此可以定义处理程序名称并在不同的记录器（root或自定义记录器）之间重用。

多对一：一个记录器可以由多个处理程序组成，例如，如果我们希望日志同时出现在控制台上，StreamHandler使用FileHandler.

过滤器

过滤器根据严重性确定输出哪些日志记录（类似于日志级别）

过滤器设置日志严重级别并记录指定严重级别及以上的所有内容。过滤器与处理程序一起在字段下定义level。

如果需要更多自定义，例如仅过滤一个特定的严重级别，则必须编写一个 Python 类，并且此过滤器将与处理程序一起定义，但现在位于 field 下filters。

模块化：过滤器以模块化的方式实现，这样过滤器名称可以在不同的处理程序中定义和重用。

多对一：一个处理程序可以由多个过滤器组成。

格式化程序

Formatters 指定日志记录的格式（类似于日志格式）

格式化程序设置日志条目的格式。格式化程序与处理程序一起定义，在字段下formatter。

模块化：格式化程序以模块化方式实现，这样格式化程序名称可以在不同的处理程序中定义和重用。

一对一：每个处理程序只能有一种日志格式。

每个处理程序都有一个唯一的文件过滤器格式设置

由于过滤器和格式化程序是与处理程序一起定义的，因此每个处理程序都有一个唯一的文件过滤器格式设置。如果需要另一个文件（StreamHandler或FileHandler）、过滤器（DEBUG或WARN级别）或格式，则应定义单独的处理程序。

带有配置文件的高级日志记录

我们现在将使用配置文件实现日志记录——它比使用basicConfig. 可以在.conf文件或字典中定义配置.py或.yml文件

字典配置可以这样定义，

import logging.config


class LevelOnlyFilter:
    def __init__(self, level):
        self.level=level

    def filter(self, record):
        return record.levelno==self.level


LOGGING_CONFIG={
    "version": 1,
    "loggers": {
        "": {  # root logger
            "level": "DEBUG",
            "propagate": False,
            "handlers": ["stream_handler", "file_handler"],
        },
        "custom_logger": {
            "level": "DEBUG",
            "propagate": False,
            "handlers": ["stream_handler"],
        },
    },
    "handlers": {
        "stream_handler": {
            "class": "logging.StreamHandler",
            "stream": "ext://sys.stdout",
            "level": "DEBUG",
            "filters": ["only_warning"],
            "formatter": "default_formatter",
        },
        "file_handler": {
            "class": "logging.FileHandler",
            "filename": "output.log",
            "mode": "w",
            "level": "DEBUG",
            "formatter": "default_formatter",
        },
    },
    "filters": {
        "only_warning": {
            "()": LevelOnlyFilter,
            "level": logging.WARN,
        },
    },
    "formatters": {
        "default_formatter": {
            "format": "%(asctime)s-%(levelname)s-%(name)s::%(module)s|%(lineno)s:: %(message)s",
        },
    },
}

logging.config.dictConfig(LOGGING_CONFIG)
logger=logging.getLogger(__name__)

我们可以观察到字典配置被分成几个部分

version（第 13 行）：将版本号表示为整数
loggers（（第 14-25 行）：定义根和自定义记录器，由一个或多个处理程序组成
handlers（第 26-41 行）：定义记录器中使用的自定义处理程序，包括特定的文件过滤器格式设置
filters（第 42-47 行）：定义在处理程序中使用的自定义过滤器
formatters（第 48-53 行）：定义在处理程序中使用的自定义格式化程序

具有.conf文件的等效实现可以是这样的，

[loggers]
keys=root,customLogger

[handlers]
keys=streamHandler,fileHandler

[formatters]
keys=defaultFormatter

[logger_root]
level=DEBUG
propagate=0
handlers=streamHandler,fileHandler

[logger_customLogger]
level=DEBUG
propagate=0
handlers=streamHandler
qualname=customLogger

[handler_streamHandler]
class=StreamHandler
args=(sys.stdout,)
level=DEBUG
formatter=defaultFormatter

[handler_fileHandler]
class=FileHandler
args=("output.log", "w")
level=DEBUG
formatter=defaultFormatter

[formatter_defaultFormatter]
format=%(asctime)s:%(levelname)s:%(name)s:%(module)s:%(funcName)s:%(lineno)s:%(message)s

要使用中定义的配置初始化记录器logging.conf，

import logging.config 
logging.config .fileConfig("logging.conf") 
logger=logging.getLogger(__name__)

比较dictConfig和fileConfig，字典实现是首选，因为它更新并且能够支持更多功能，例如使用自定义过滤器。

比较logging.config和logging.basicConfig，使用配置文件可以减少重复代码的数量，并将配置抽象到单独的字典或配置文件中，这是跨多个文件执行日志记录的首选方式。

常见问题

在本节中，我将讨论使用配置文件实现日志记录的一些常见问题和注意事项。

日志配置覆盖

有几种方式可以发生日志配置覆盖。

№1：同时使用logging.basicConfig和logging.config

如果不同的文件使用不同的方法来实例化记录器，并且在这些文件之间进行了一些导入，使得日志配置中存在冲突，则logging.config实现优先logging.basicConfig并被覆盖。

№2：在记录器级别与处理程序级别定义的日志级别

如果您在字典和logging.conf文件中注意到，日志级别被定义了两次，一次在记录器定义中，另一次在处理程序定义中。较高的严重级别优先，其次是记录器级别优先于处理程序级别。

为了使这项工作对您有利，我们可以将记录器级别设置为最低严重性，DEBUG并使用处理程序级别来控制级别。如果一个级别应该跨多个处理程序标准化，请随意在记录器定义中定义级别。

继承

在继承期间，日志将被传递给记录器及其高级（祖先）记录器，从而导致日志条目重复。默认情况下，所有自定义记录器都从root记录器继承。

为了防止继承导致重复日志，我们可以在配置中定义记录器时指定propagate字段。False

希望您对日志记录的组件以及如何使用配置文件以可重用和可扩展的方式实现它有更多的了解！与普通的打印语句相比，日志记录有助于开发人员更好地控制和理解代码库，并且在调试大型项目中的代码时特别有用。

感谢您的阅读！如果您喜欢这篇文章，请随时分享

文转载自微信公众号“前端先锋”（jingchengyideng）。

每个前端都会用 JavaScript 控制台打开日志或调试。但是 console 对象比 console.log() 有更多的东西。

计算属性名称

ES6 的计算属性名称特别有用，因为它们可以通过在变量周围添加一对大括号来帮你识别的变量。

const x=1, y=2, z=3; 
 
console.log({x, y, z}); // {x: 1, y: 2, z: 3}

console.trace()

console.trac() 与 console.log() 完全相同，但它也会输出整个栈跟踪，能让你确切地知道到底发生了什么。

const outer=()=> { 
  const inner=()=> console.trace('Hello'); 
  inner(); 
}; 
 
outer(); 
/* 
  Hello 
  inner @ VM207:3 
  outer @ VM207:5 
  (anonymous) @ VM228:1 
*/

console.group()

console.group() 可以把日志分组为可折叠的结构，当有多个日志时特别有用。

console.group('Outer');           // 创建一个名为 'Outer' 的组 
console.log('Hello');             // 在 'Outer' 组中输出日志 
console.groupCollapsed('Inner');  // 创建一个名为 'Inner' 的组，折叠状态 
console.log('Hellooooo');         // 在 'Inner' 组中输出日志 
console.groupEnd();               // 结束当前组, 'Inner' 
console.groupEnd();               // 结束当前组, 'Outer' 
console.log('Hi');                // 在组外输出日志

日志级别

除了 console.log() 之外，还有其他一些日志记录级别，例如 [console.debug()](https://developer.mozilla.org/en-US/docs/Web/API/Console /debug)、 console.info()、 console.warn()和 console.error()。

console.debug('Debug message'); 
console.info('Useful information'); 
console.warn('This is a warning'); 
console.error('Something went wrong!');

console.assert()

console.assert() 提供了一种简便的方法，仅在断言失败时将某些内容记录为错误(例如当第一个参数为 false 时)，否则完全跳过日志。

const value=10; 
 
console.assert(value===10, 'Value is not 10!'); // 不输出日志 
console.assert(value===20, 'Value is not 20!'); // 输出日志："Value is not 20!"

console.count()

可以用 console.count() 来统计一段代码执行了多少次。

Array.from({ length: 4 }).forEach( 
  ()=> console.count('items')  // 名为 items 的计数器 
); 
/* 
  items: 1 
  items: 2 
  items: 3 
  items: 4 
*/ 
console.countReset('items');  // 重置计数器

console.time()

console.time() 提供了一种快速检查代码性能的方法，但是由于精度较低，不可用于真正的基准测试。

console.time('slow comp');     
console.timeLog('slow comp');  
console.timeEnd('slow comp');

CSS

最后一个，还可以在 console.log() 中用 %c 字符串替换表达式将 CSS 应用于日志的各个部分。

在线咨询

上一篇：HTML5又迎元年影游联动也许能救？
下一篇：html5前端教程：Flexbox 布局的最简单表单

您的项目需求

*请认真填写需求信息，我们会在24小时内与您取得联系。

整合营销服务商