エラー/例外をログに記録する対象者

Question

ログgin例外が発生したときのベストプラクティスを理解しようとしています。

これまでのところ、例外を検出するたびにログを記録しています。しかし、下部のレバークラスが例外（データベースレイヤーから）をキャッチして、それを私たち自身のアプリケーション例外でラップすると、そこに元の例外を記録するのか、それとも上部のレバークラスにすべての詳細を記録させるべきですか？
入力パラメータが悪いため、下位レベルのクラスが例外をスローする場所はどうですか？そこに例外をログするか、もう一度、catchingコードにログを記録させますか？

Answer 1

主に、下位レベルのキャッチと上位レベルのキャッチの両方でログに記録するのは避けてください。これにより、ログに冗長な情報（ログに書き込むために追加のIOリソースを必要としません）が肥大化します。

例外処理に関する一般的なベストプラクティス情報をお探しの場合はthis link is handyです。

Answer 2

ログあなたがキャッチする場所は、あなたがラップしている場合です。下位ラッパーがそうでない場合は、デバッグ可能性の理由があります。しかし、あなたが良性を知らないか、またはあなたがそれを扱うことができない限り、例外を飲み込まないでください。

あなたは上の例外をログに記録し、合格する必要がある場合、私は

try{ 
. 
. 
. 
} catch(Exception ex){ 
... log .... 
throw; 
} 

をお勧めしたいです。

Answer 3

ロギングコード（a）が例外のスタックトレースを記録し、（b）内部例外のチェーン全体を次のようにログに記録している限り、よく

Microsoft例外処理アプリケーションブロックは、これらの両方を処理します。私は他のロギングフレームワークも同じようになると思います。

Answer 4

私のwinformのアプリケーションでは、ログ用にObserverを作成しました。 Observerには購読者がいます。購読者はどこかにログを書き込んだり、処理したりすることができます。 それは見た目です：

public static class LoggingObserver 
    { 
     /// <summary> 
     /// Last getted log message 
     /// </summary> 
     public static string LastLog; 

     /// <summary> 
     /// Last getted exception 
     /// </summary> 
     public static Exception LastException; 

     /// <summary> 
     /// List of log's processors 
     /// </summary> 
     public static List<BaseLogging> loggings = new List<BaseLogging>(); 

     /// <summary> 
     /// Get Exception and send for log's processors 
     /// </summary> 
     /// <param name="ex">Exception with message</param> 
     public static void AddLogs(Exception ex) 
     { 
      LastException = ex; 
      LastLog = string.Empty; 
      foreach (BaseLogging logs in loggings) 
      { 
       logs.AddLogs(ex); 
      } 
     } 

     /// <summary> 
     /// Get message log for log's processors 
     /// </summary> 
     /// <param name="str">Message log</param> 
     public static void AddLogs(string str) 
     { 
      LastException = null; 
      LastLog = str; 
      foreach (BaseLogging logs in loggings) 
      { 
       logs.AddLogs(str); 
      } 
     } 

     /// <summary> 
     /// Close all processors 
     /// </summary> 
     public static void Close() 
     { 
      foreach (BaseLogging logs in loggings) 
      { 
       logs.Close(); 
      } 
     } 
    } 

加入者の抽象クラス：ファイルへログインするための

public abstract class BaseLogging 
    { 
     /// <summary> 
     /// Culture (using for date) 
     /// </summary> 
     public CultureInfo culture; 

     /// <summary> 
     /// Constructor 
     /// </summary> 
     /// <param name="culture">Culture</param> 
     public BaseLogging(CultureInfo culture) 
     { 
      this.culture = culture; 
     } 

     /// <summary> 
     /// Add log in log system 
     /// </summary> 
     /// <param name="str">message of log</param> 
     public virtual void AddLogs(string str) 
     { 
      DateTime dt = DateTime.Now; 

      string dts = Convert.ToString(dt, culture.DateTimeFormat); 

      WriteLine(String.Format("{0} : {1}", dts, str)); 
     } 

     /// <summary> 
     /// Add log in log system 
     /// </summary> 
     /// <param name="ex">Exception</param> 
     public virtual void AddLogs(Exception ex) 
     { 
      DateTime dt = DateTime.Now; 

      string dts = Convert.ToString(dt, culture.DateTimeFormat); 
      WriteException(ex); 
     } 

     /// <summary> 
     /// Write string on log system processor 
     /// </summary> 
     /// <param name="str">logs message</param> 
     protected abstract void WriteLine(string str); 

     /// <summary> 
     /// Write string on log system processor 
     /// </summary> 
     /// <param name="ex">Exception</param> 
     protected abstract void WriteException(Exception ex); 

     /// <summary> 
     /// Close log system (file, stream, etc...) 
     /// </summary> 
     public abstract void Close(); 
    } 

と実装：

使用

/// <summary> 
    /// Logger processor, which write log to some stream 
    /// </summary> 
    public class LoggingStream : BaseLogging 
    { 
     private Stream stream; 

     /// <summary> 
     /// Constructor. 
     /// </summary> 
     /// <param name="stream">Initialized stream</param> 
     /// <param name="culture">Culture of log system</param> 
     public LoggingStream (Stream stream, CultureInfo culture) 
      : base(culture) 
     { 
      this.stream = stream; 
     } 

     /// <summary> 
     /// Write message log to stream 
     /// </summary> 
     /// <param name="str">Message log</param> 
     protected override void WriteLine(string str) 
     { 
      try 
      { 
       byte[] bytes; 

       bytes = Encoding.ASCII.GetBytes(str + "\n"); 
       stream.Write(bytes, 0, bytes.Length); 
       stream.Flush(); 
      } 
      catch { } 
     } 

     /// <summary> 
     /// Write Exception to stream 
     /// </summary> 
     /// <param name="ex">Log's Exception</param> 
     protected override void WriteException(Exception ex) 
     { 
      DateTime dt = DateTime.Now; 

      string dts = Convert.ToString(dt, culture.DateTimeFormat); 
      string message = String.Format("{0} : Exception : {1}", dts, ex.Message); 
      if (ex.InnerException != null) 
      { 
       message = "Error : " + AddInnerEx(ex.InnerException, message); 
      } 
      WriteLine(message); 
     } 
     /// <summary> 
     /// Closing stream 
     /// </summary> 
     public override void Close() 
     { 
      stream.Close(); 
     } 

     private string AddInnerEx(Exception exception, string message) 
     { 
      message += "\nInner Exception : " + exception.Message; 
      if (exception.InnerException != null) 
      { 
       message = AddInnerEx(exception.InnerException, message); 
      } 
      return message; 
     } 
    } 

：

​​