Est-il possible d'améliorer ce simple wrapper Log4Net?

Question

J'ai écrit un simple wrapper log4net. Je me demandais si ce code d'emballage pourrait être amélioré.

Je suis un peu préoccupé par le code de réflexion introduit dans chaque fonction de journalisation (Info, Warn, etc.) pour obtenir le nom de la fonction Calling. Y a-t-il des problèmes de performance possibles en raison de cela?

namespace Acqueon.Pacer.Core.Helpers 
{ 
    #region Imports 

    using System; 
    using System.Diagnostics; 
    using System.Reflection; 

    using log4net; 

    #endregion 

    /// <summary> 
    /// log4net Log helper 
    /// </summary> 
    public sealed class Logger 
    { 
     #region Constants and Fields 

     /// <summary> 
     /// Determines whether the DEBUG Mode is enabled. 
     /// </summary> 
     private readonly bool isDebugEnabled; 

     /// <summary> 
     /// The is error enabled. 
     /// </summary> 
     private readonly bool isErrorEnabled; 

     /// <summary> 
     /// Determines whether the FATAL Mode is enabled. 
     /// </summary> 
     private readonly bool isFatalEnabled; 

     /// <summary> 
     /// Determines whether the INFO Mode is enabled. 
     /// </summary> 
     private readonly bool isInfoEnabled; 

     /// <summary> 
     /// Determines whether the WARN Mode is enabled. 
     /// </summary> 
     private readonly bool isWarnEnabled; 

     /// <summary> 
     /// The logger object 
     /// </summary> 
     private readonly ILog log; 

     #endregion 

     #region Constructors and Destructors 

     /// <summary> 
     /// Initializes a new instance of the Logger class. 
     /// </summary> 
     public Logger() 
      : this(new StackTrace().GetFrame(1).GetMethod().DeclaringType) 
     { 
     } 

     /// <summary> 
     /// Initializes a new instance of the Logger class. 
     /// </summary> 
     /// <param name="type"> 
     /// The type of logger. 
     /// </param> 
     public Logger(Type type) 
     { 
      this.log = LogManager.GetLogger(type); 

      this.isDebugEnabled = this.log.IsDebugEnabled; 
      this.isErrorEnabled = this.log.IsErrorEnabled; 
      this.isInfoEnabled = this.log.IsInfoEnabled; 
      this.isFatalEnabled = this.log.IsFatalEnabled; 
      this.isWarnEnabled = this.log.IsWarnEnabled; 
     } 

     #endregion 

     #region Public Methods 

     /// <summary> 
     /// Logs the debug message. 
     /// </summary> 
     /// <param name="message"> 
     /// The message. 
     /// </param> 
     public void Debug(string message) 
     { 
      if (this.isDebugEnabled) 
      { 
       MethodBase methodBase = new StackTrace().GetFrame(1).GetMethod(); 
       this.log.Debug(methodBase.Name + " : " + message); 
      } 
     } 

     /// <summary> 
     /// Logs the debug message and the exception. 
     /// </summary> 
     /// <param name="message"> 
     /// The message. 
     /// </param> 
     /// <param name="exception"> 
     /// The exception. 
     /// </param> 
     public void Debug(string message, Exception exception) 
     { 
      if (this.isDebugEnabled) 
      { 
       MethodBase methodBase = new StackTrace().GetFrame(1).GetMethod(); 
       this.log.Debug(methodBase.Name + " : " + message, exception); 
      } 
     } 

     /// <summary> 
     /// Logs the error message. 
     /// </summary> 
     /// <param name="errorMessage"> 
     /// The error message. 
     /// </param> 
     public void Error(string errorMessage) 
     { 
      if (this.isErrorEnabled) 
      { 
       MethodBase methodBase = new StackTrace().GetFrame(1).GetMethod(); 
       this.log.Error(methodBase.Name + " : " + errorMessage); 
      } 
     } 

     /// <summary> 
     /// Logs the error message and the exception. 
     /// </summary> 
     /// <param name="errorMessage"> 
     /// The error message. 
     /// </param> 
     /// <param name="exception"> 
     /// The exception. 
     /// </param> 
     public void Error(string errorMessage, Exception exception) 
     { 
      if (this.isErrorEnabled) 
      { 
       MethodBase methodBase = new StackTrace().GetFrame(1).GetMethod(); 
       this.log.Error(methodBase.Name + " : " + errorMessage, exception); 
      } 
     } 

     /// <summary> 
     /// Logs the fatal error message. 
     /// </summary> 
     /// <param name="message"> 
     /// The message. 
     /// </param> 
     public void Fatal(string message) 
     { 
      if (this.isFatalEnabled) 
      { 
       MethodBase methodBase = new StackTrace().GetFrame(1).GetMethod(); 
       this.log.Fatal(methodBase.Name + " : " + message); 
      } 
     } 

     /// <summary> 
     /// Logs the fatal error message and the exception. 
     /// </summary> 
     /// <param name="message"> 
     /// The message. 
     /// </param> 
     /// <param name="exception"> 
     /// The exception. 
     /// </param> 
     public void Fatal(string message, Exception exception) 
     { 
      if (this.isFatalEnabled) 
      { 
       MethodBase methodBase = new StackTrace().GetFrame(1).GetMethod(); 
       this.log.Fatal(methodBase.Name + " : " + message, exception); 
      } 
     } 

     /// <summary> 
     /// Logs the info message. 
     /// </summary> 
     /// <param name="message"> 
     /// The message. 
     /// </param> 
     public void Info(string message) 
     { 
      if (this.isInfoEnabled) 
      { 
       MethodBase methodBase = new StackTrace().GetFrame(1).GetMethod(); 
       this.log.Info(methodBase.Name + " : " + message); 
      } 
     } 

     /// <summary> 
     /// Logs the info message and the exception. 
     /// </summary> 
     /// <param name="message"> 
     /// The message. 
     /// </param> 
     /// <param name="exception"> 
     /// The exception. 
     /// </param> 
     public void Info(string message, Exception exception) 
     { 
      if (this.isInfoEnabled) 
      { 
       MethodBase methodBase = new StackTrace().GetFrame(1).GetMethod(); 
       this.log.Info(methodBase.Name + " : " + message, exception); 
      } 
     } 

     /// <summary> 
     /// Logs the warning message. 
     /// </summary> 
     /// <param name="message"> 
     /// The message. 
     /// </param> 
     public void Warn(string message) 
     { 
      if (this.isWarnEnabled) 
      { 
       MethodBase methodBase = new StackTrace().GetFrame(1).GetMethod(); 
       this.log.Warn(methodBase.Name + " : " + message); 
      } 
     } 

     /// <summary> 
     /// Logs the warning message and the exception. 
     /// </summary> 
     /// <param name="message"> 
     /// The message. 
     /// </param> 
     /// <param name="exception"> 
     /// The exception. 
     /// </param> 
     public void Warn(string message, Exception exception) 
     { 
      if (this.isWarnEnabled) 
      { 
       MethodBase methodBase = new StackTrace().GetFrame(1).GetMethod(); 
       this.log.Warn(methodBase.Name + " : " + message, exception); 
      } 
     } 

     #endregion 
    } 
} 

Answer 1

Pourquoi ne pas utiliser ceci:

Les motifs de PatternLayout suivants extraire des informations de localisation:

% F Utilisé pour la sortie le nom du fichier dans lequel a été émis la demande d'enregistrement

% L Utilisé pour sortir le numéro de ligne à partir duquel la demande d'enregistrement a été émise

% M Utilisé pour sortir la méthode nom où la demande de consignation a été émise

% C Utilisé pour générer le nom de classe complet de l'appelant qui émet la demande de consignation .

Veuillez noter que dans les deux cas, une marche en pile est requise, ce qui est coûteux.

<appender name="DebugOut" 
     type="log4net.Appender.OutputDebugStringAppender"> 
<layout type="log4net.Layout.PatternLayout"> 
    <conversionPattern value="%-5p [%t] %C{1}.%M - %m%n" /> 
</layout> 

Answer 2

Il y aura éventuellement un coup de performance à partir du code de réflexion, en fonction évidemment du nombre de messages de journal que vous connectez tout au long de votre application.

Vous pouvez également déjà fournir un numéro de ligne, une pile d'appels de base et des informations de méthode en utilisant le modèle de conversion correct. Cette fonctionnalité est présente dans log4net par défaut - et les docs vous avertissent qu'il y a un hit de performance. Enfin, je voudrais implémenter votre classe wrapper comme méthodes d'extension sur Exception.