Кто должен регистрировать ошибку/исключение

Question

Я пытаюсь выяснить лучшие практики при исключениях loggin.

До сих пор я регистрирую каждый раз, когда попадаю в исключение. Но когда класс нижнего рычага выхватывает исключение (скажем, из слоя базы данных) и обертывает его в нашем собственном исключении приложения - должен ли я также регистрировать исходное исключение, или я должен просто позволить верхнему классу рычагов записывать все детали?
А как насчет мест, где мой класс нижнего уровня решает выбросить исключение из-за неправильных входных параметров? Должен ли он регистрировать это исключение, или, еще раз, просто разрешить ловушку?

Answer 1

В основном вы должны избегать его регистрации как для улова более низкого уровня, так и для улова более высокого уровня, поскольку это раздувает журнал с избыточной информацией (не говоря уже о необходимости использования дополнительных ресурсов ввода-вывода для записи в журнал).

Если вы ищете общую информацию об оптимальной практике обработки исключений, this link is handy.

Answer 2

журнал, где вы ловите, если вы обертываете, то вам следует. Если нижняя оболочка не делает этого, у вас есть причина (для отладки) сделать это. Однако не проглатывайте исключение, если вы не знаете его доброкачественного или можете его обработать.

Я предлагаю

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

, если вам нужно войти и передать исключение дальше.

Answer 3

Вы можете уйти с регистрацией только один раз на самом верхнем уровне вашего приложения, если ваш код регистрации (a) регистрирует трассировку стека исключения и (b) регистрирует всю цепочку внутренних исключений как Что ж.

Блок приложений для обработки исключений Microsoft заботится обо всех этих вещах для вас. Я предполагаю, что другие рамки ведения журналов будут делать то же самое.

Answer 4

В моих приложениях winform я создал Наблюдателя для ведения журнала. У наблюдателя есть подписчики, которые могут где-то записывать журнал или обрабатывать его. Это вид:

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; 
     } 
    } 

Использование:

//initialization 
FileStream FS = new FileStream(LogFilePath, FileMode.Create); 
LoggingObserver.loggings.Add(new LoggingStream(FS, Thread.CurrentThread.CurrentCulture)); 
//write exception 
catch (Exception ex) { 
LoggingObserver.AddLog(new Exception ("Exception message", ex)); 
} 
//write log 
LoggingObserver.AddLog("Just a log");