blocks|key|2992890|text|从长远来看，注入更加灵活，因为你可以很容易地有选择地注入到某些地方，并有选择地禁用日志记录等。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2992891|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Injection is more flexible in the long run, since you can easily selectively inject into certain places and disable logging selectively, etc.

blocks|key|4460240|text|我认为注射它没有什么错。他们建议仅出于性能原因而使用静态变量，但我认为这与在启动时注入记录器没有什么不同。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4460241|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

I think there is nothing wrong with injecting it. They recommend using static variables merely for performance reasons, but I see little difference between this and injecting a logger at start up.

blocks|key|2992927|text|如果内存性能不是太大的问题，你可以考虑面向方面编程，例如使用PostSharp。这样，您的类根本不需要知道记录器。基本上，您可以将IL代码作为构建后步骤直接注入到您的程序集中。PostSharp使用属性来标记方法、类甚至整个程序集。甚至还有一个用于使用log4net进行日志记录的plugin。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2992928|编辑:我提到了内存，因为每个属性都会为每个连接点创建一个新对象。|2992929|entityMap|0|LINK|mutability|MUTABLE|url|http://www.postsharp.org/|1|http://code.google.com/p/postsharp-user-plugins/wiki/Log4PostSharp^0|U|9|0|3W|6|1|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@$A|Q|B|R|1|S]|$A|T|B|U|1|V]]|C|$]]|$1|D|3|E|5|6|7|W|8|@]|9|@]|C|$]]|$1|F|3|-4|5|6|7|X|8|@]|9|@]|C|$]]]|G|$H|$5|I|J|K|C|$L|M]]|N|$5|I|J|K|C|$L|O]]]]

If memory performance is not that much of an issue you might consider AOP, e.g. using <a href="http://www.postsharp.org/" rel="nofollow noreferrer">PostSharp</a>. That way your classes don't need to know the logger at all. You basically inject IL-code right into your assembly as a postbuild step. PostSharp uses attributes for marking methods, classes and even whole assemblies. There's even a <a href="http://code.google.com/p/postsharp-user-plugins/wiki/Log4PostSharp" rel="nofollow noreferrer">plugin</a> for using log4net for the logging concern.

EDIT:
I mentioned memory because with each attribute you create a new object for each join point.

blocks|key|933206|text|即使您声明日志记录不会改变，我还是建议从特定的日志记录框架中抽象出来。然而，并不是在所有情况下都需要注入记录器实例。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|933207|以CommonLogging+(有关什么是Common.Logging的简短描述，请参阅this+Stackoverflow+answer+)为例:您的类直接与工厂(LoggerManager)对话，但您并不绑定到特定的记录器实现。|offset|length|933208|entityMap|0|LINK|mutability|MUTABLE|url|http://netcommon.sourceforge.net/|1|https://stackoverflow.com/questions/1110638/file-logger-in-c/1114617#1114617^0|0|1|D|0|18|P|1|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@$D|R|E|S|1|T]|$D|U|E|V|1|W]]|A|$]]|$1|F|3|-4|5|6|7|X|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|M]]|N|$5|I|J|K|A|$L|O]]]]

Even though you stated that logging isn't going to change, I suggest to abstract away from a specific logging framework. Injecting a logger instance however isn't needed in all cases. 

Take <a href="http://netcommon.sourceforge.net/" rel="nofollow noreferrer">CommonLogging</a> (see <a href="https://stackoverflow.com/questions/1110638/file-logger-in-c/1114617#1114617">this Stackoverflow answer</a> for a short description of what Common.Logging is) for instance: Your class talks directly to the factory (LoggerManager) but you are not bound to a specific logger implementation.

blocks|key|940142|text|如果您正在谈论依赖注入(比如在Spring.NET意义上)，那么这并不重要--尽管您不会从记录器实例的多个副本中获得太多价值。通常，框架返回的具有特定类/名称的每个记录器实例都将是一个单例，因此问题是，您是否希望用一个记录器引用来打乱每个实例，而不是每个类一个静态引用。如果您关心日志记录器实现的更改，那么可以登录到一个接口(在另一个答案中提到的CommonLogging可以做到这一点，并且同时支持log4net和企业库实现)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|940143|如果您正在谈论使用AOP的注入，那么我不确定AOP注入是否在一定程度上更加灵活。您只能记录进入、退出和异常，而方法级别的granularity.AOP注入更像是一种分散的方法，即使您使用AOP选择性地注入到代码的各个部分中。尽管日志被吹捧为一种横切关注点，这对于AOP来说是理想的，但我从未发现基于AOP的日志在实践中有很大用处(当然是YMMV)。|940144|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

If you are talking about dependency injection (say in the Spring.NET sense) then it doesn't much matter - though you don't get much value from multiple copies of logger instances. Typically, each logger instance returned by a framework with a specific class/name will be a singleton anyway, so the question is whether you want to clutter each instance with a logger reference, rather than a single static reference per class. If you are concerned about changing logger implementations, then log to an interface (CommonLogging, mentioned in another answer, does this, and supports both log4net and Enterprise Library implementations).

If you are talking about injection using AOP, then I'm not sure that beyond a certain point, AOP injection is more flexible. You are pretty much limited to logging entry, exit and exceptions with method-level granularity.AOP Injection is more of a scatter-shot approach, even if you use AOP to selectively inject into parts of your code. Although logging is touted as a cross-cutting concern of the kind which which is ideal for AOP, I've never found AOP-based logging to be much use in practice (YMMV, of course).

blocks|key|933248|text|CSharpAtl，|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|933249|我很好奇你到底是如何注入Log4net的？请查看我的问题/社区维基here。|933250|我还看到了您对DI/Log4net问题here的回答。|933251|我见过的大多数日志注入示例都显示了一个类注入了一个"logger“，如下所示：|933252|public+class+Foo
{
++private+ILogger+logger;

++public+Foo(ILogger+logger)+//Injection+via+constructor
++{
++++//Which+"named"+logger+is+this+anyway?++Is+it+Foo's?++If+so,+how+is+it+Foo's?
++++this.logger+=+logger;
++}

++public+DoSomeWork(int+xyz)
++{
++++logger.Info("xyz+=+{0}",+xyz);
++}
}|code-block|syntax|javascript|933253|使用Log4net+(和NLog，也许还有其他)之类的工具，您通常会创建一个如下所示的记录器：|933254|public+class+Foo
{
++private+static+ILogger+logger+=+
++++++++++LogManager.GetLogger(
++++++++++++++System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);

++public+Foo()
++{
++}

++public+DoSomeWork(int+xyz)
++{
++++logger.Info("xyz+=+{0}",+xyz);
++}
}|933255|那么，如果我进行依赖注入，我的类Foo如何获得正确的记录器呢？另外，也许我没有严格地根据类来命名我的记录器。相反，我可能会根据可能无法从类型派生的功能区域(如"DatabaseAccess“、"AppStartup”、"AppShutdown“等)来命名它们。|933256|您注入的是"Logger“(对应于命名记录器)，还是"LogManager”(对应于Log4net的Log4Net的LogManager)，或者您正在做其他事情？您是否使用DI平台的配置功能来关联注入依赖项的“命名实例”？我认为Unity支持这样的东西，尽管我不是很确定。|933257|以下是我设想的注入"LogManager“的工作方式：|933258|public+class+Foo
{
++private+static+ILogger+logger;

++public+Foo(ILogManager+logManager)+//Injection+via+constructor
++{
++++logger+=+logManager.GetLogger
++++++++++++++++++++(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);

++++//Since+logger+is+(should+it+be?)+static,+maybe+should+be+like+this:

++++if+(logger+=+null)
++++{
++++++logManager.GetLogger
+++++++++++++++++(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
++++}
++}

++public+DoSomeWork(int+xyz)
++{
++++logger.Info("xyz+=+{0}",+xyz);
++}
}|933259|在我看来，注入像ILogManager这样的东西(其实现将包装Log4net的LogManager)将比注入ILogger更容易，因为DI平台如何知道要注入哪个ILogger。|933260|我是DI和.NET日志记录平台的新手(实际上，一般来说，我对C#和.NET也是非常陌生的)。在过去的许多年里，我的大部分经验都是VB6+%2B+VC%2B%2B+6。|933261|谢谢你提供的任何信息。|933262|开始编辑...|933263|我看了更多关于AutoFac的文章，发现你也问到了AutoFac，所以我猜你是在为你的DI使用它。如果这是真的，那么我猜您也在做一些类似this的事情，或者，显然更好的是，像this一样来解析您的记录器(按类类型)。我猜这回答了一个问题，即如何(至少在AutoFac中)注入命名记录器(例如来自Log4Net或NLog的记录器)。|933264|结束编辑...|933265|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/users/11907/csharpatl|1|https://stackoverflow.com/questions/3452318/dependency-injection-and-named-loggers|2|https://stackoverflow.com/questions/940831/how-to-use-log4net-with-dependency-injection/940860#940860|3|https://stackoverflow.com/questions/1159212/automatic-factory-with-common-logging-and-autofac|4|http://groups.google.com/group/autofac/msg/704f926779cbe8b3^0|0|9|0|0|X|4|1|0|J|4|2|0|0|0|0|0|0|0|0|0|0|0|0|0|1W|4|3|2F|4|4|0|0^^$0|@$1|2|3|4|5|6|7|1S|8|@]|9|@$A|1T|B|1U|1|1V]]|C|$]]|$1|D|3|E|5|6|7|1W|8|@]|9|@$A|1X|B|1Y|1|1Z]]|C|$]]|$1|F|3|G|5|6|7|20|8|@]|9|@$A|21|B|22|1|23]]|C|$]]|$1|H|3|I|5|6|7|24|8|@]|9|@]|C|$]]|$1|J|3|K|5|L|7|25|8|@]|9|@]|C|$M|N]]|$1|O|3|P|5|6|7|26|8|@]|9|@]|C|$]]|$1|Q|3|R|5|L|7|27|8|@]|9|@]|C|$M|N]]|$1|S|3|T|5|6|7|28|8|@]|9|@]|C|$]]|$1|U|3|V|5|6|7|29|8|@]|9|@]|C|$]]|$1|W|3|X|5|6|7|2A|8|@]|9|@]|C|$]]|$1|Y|3|Z|5|L|7|2B|8|@]|9|@]|C|$M|N]]|$1|10|3|11|5|6|7|2C|8|@]|9|@]|C|$]]|$1|12|3|13|5|6|7|2D|8|@]|9|@]|C|$]]|$1|14|3|15|5|6|7|2E|8|@]|9|@]|C|$]]|$1|16|3|17|5|6|7|2F|8|@]|9|@]|C|$]]|$1|18|3|19|5|6|7|2G|8|@]|9|@$A|2H|B|2I|1|2J]|$A|2K|B|2L|1|2M]]|C|$]]|$1|1A|3|1B|5|6|7|2N|8|@]|9|@]|C|$]]|$1|1C|3|-4|5|6|7|2O|8|@]|9|@]|C|$]]]|1D|$1E|$5|1F|1G|1H|C|$1I|1J]]|1K|$5|1F|1G|1H|C|$1I|1L]]|1M|$5|1F|1G|1H|C|$1I|1N]]|1O|$5|1F|1G|1H|C|$1I|1P]]|1Q|$5|1F|1G|1H|C|$1I|1R]]]]

<a href="https://stackoverflow.com/users/11907/csharpatl">CSharpAtl</a>,

I am curious as to exactly how you are injecting Log4net? See my question/community wiki <a href="https://stackoverflow.com/questions/3452318/dependency-injection-and-named-loggers">here</a>.

I also saw your answer to a DI/Log4net question <a href="https://stackoverflow.com/questions/940831/how-to-use-log4net-with-dependency-injection/940860#940860">here</a>.

Most logging injection examples that I have seen show a class having a "logger" injected, something like this:

<pre><code>public class Foo
{
 private ILogger logger;

 public Foo(ILogger logger) //Injection via constructor
 {
 //Which "named" logger is this anyway? Is it Foo's? If so, how is it Foo's?
 this.logger = logger;
 }

 public DoSomeWork(int xyz)
 {
 logger.Info("xyz = {0}", xyz);
 }
}
</code></pre>

With something like Log4net (and NLog, and maybe others), you typically create a logger like this:

<pre><code>public class Foo
{
 private static ILogger logger = 
 LogManager.GetLogger(
 System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);

 public Foo()
 {
 }

 public DoSomeWork(int xyz)
 {
 logger.Info("xyz = {0}", xyz);
 }
}
</code></pre>

So, how does my class, Foo, get the correct logger if I dependency inject? Also, maybe I am not naming my loggers based strictly on the class. Rather, I might name them based on functional area (like "DatabaseAccess", "AppStartup", "AppShutdown", etc) that might not be derivable from type.

Are you injecting a "Logger" (that would correspond to a named logger), or a "LogManager" (that would correspond to Log4net's LogManager), or are you doing something else? Do you use a configuration capability of a DI platform to associate "named instances" of injected dependencies? I think that Unity supports something like this, although I am not really sure.

Here is how I would imagine injecting a "LogManager" would work:

<pre><code>public class Foo
{
 private static ILogger logger;

 public Foo(ILogManager logManager) //Injection via constructor
 {
 logger = logManager.GetLogger
 (System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);

 //Since logger is (should it be?) static, maybe should be like this:

 if (logger = null)
 {
 logManager.GetLogger
 (System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
 }
 }

 public DoSomeWork(int xyz)
 {
 logger.Info("xyz = {0}", xyz);
 }
}
</code></pre>

It seems to me that injecting something like ILogManager (the implementation of which would wrap Log4net's LogManager) would be easier than injectng ILogger, because of the question of how the DI platform would know which ILogger to inject.

I am new to DI and .NET logging platforms (and actually, pretty new to C# and .NET in general). The vast majority of my experience over the last many years is VB6 + VC++ 6.

Thanks for ANY info ...

Begin edit ...

I have looked around on SO some more and have found that you have also asked about AutoFac, so I am guessing that you are using this for your DI. If that is true, then I guess that you are also doing something like <a href="https://stackoverflow.com/questions/1159212/automatic-factory-with-common-logging-and-autofac">this</a> or, apparently even better, like <a href="http://groups.google.com/group/autofac/msg/704f926779cbe8b3" rel="nofollow noreferrer">this</a> to resolve your logger (by class type). I guess that answers the question of how, at least in AutoFac, to inject named loggers (such as from Log4Net or NLog).

End edit ...

Should a logging framework be injected into classes that need them or should every class that needs it just know the framework and use it directly? I am using Log4Net and currently I am injecting a service that wraps that framework into the classes that need to be able to log, knowing logging is probably not going to change and that most pieces need it, is injecting the answer in this sense?

Logging framework being injected into classes

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云AI代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

功能1上新10个字符

功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符。

功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符。

功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符

功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符

功能4上新

文章&问答评论现已支持表情

全新交互，全新视觉，新增快捷键、悬浮工具栏、高亮块等功能并同时优化现有功能，全面提升创作效率和体验

社区富文本编辑器全新改版！诚邀体验～ 

精选全网热门MCP server，让你的AI更好用 🚀

💥开发者 MCP广场重磅上线！

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

日志记录框架是应该注入到需要它们的类中，还是应该让每个需要它的类都知道这个框架并直接使用它？我正在使用Log4Net，目前我正在将一个服务注入到需要能够记录日志的类中，它包装了这个框架，知道日志记录可能不会改变，并且大多数部分都需要它，在这种意义上注入答案吗？

问注入到类中的日志框架
EN

回答 6

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问注入到类中的日志框架EN

回答 6

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问注入到类中的日志框架
EN