2009-08-20 1 views
2

WCF 서비스에서 특정 프로세스를 수행 할 때마다 별도의 로그를 작성하려고합니다. 이미 log4net을 사용하는 전체 응용 프로그램에 대한 표준 로그가 있습니다. 나는 특정 프로세스를위한 appender와 필터를 추가하고 제거해야합니까? 이 프로세스는 업로드 된 파일을 처리합니다. 다른 아이디어 ???log4net .... 별도의 로그 파일

답변

1

I'ved 전에, 우리는이 같은 코드 뭔가 사용 비슷한 일을 수행

올리을

class Program 
{ 
    static void Main(string[] args) 
    { 
     log4net.Config.BasicConfigurator.Configure(); 

     var file = Path.Combine(Directory.GetCurrentDirectory(), Guid.NewGuid() + ".log"); 
     var log = InitialiseLogToFile(file); 
     log.Info("Made it here!"); 
     log.Error("Made it here!"); 

     var file2 = Path.Combine(Directory.GetCurrentDirectory(), Guid.NewGuid() + ".log"); 
     var log2 = InitialiseLogToFile(file2); 
     log2.Info("Made it here!"); 
     log2.Error("Made it here!"); 
    } 

    public static ILog InitialiseLogToFile(string file) 
    { 
     LogManager.ResetConfiguration(); 
     var hierarchy = (Hierarchy)LogManager.GetLoggerRepository(); 

     var patternLayout = new PatternLayout(); 
     patternLayout.ConversionPattern = "%d [%t] %-5p %c [%x] - %m%n"; 
     patternLayout.ActivateOptions(); 

     var appender = new FileAppender {File = file, AppendToFile = true, Layout = patternLayout}; 
     appender.ActivateOptions(); 

     var logger = (Logger)hierarchy.GetLogger(file); 
     logger.AddAppender(appender); 
     hierarchy.Configured = true; 

     return LogManager.GetLogger(file); 
    } 
} 
+0

내 질문에 분명하지 않은 문제가 있습니다. 업로드 후에 파일을 실행하고 있으며 파일을 처리 할 때마다 로그 파일을 원합니다. appender를 추가하고 필터를 사용하지 않으면 하나의 파일을 처리하기위한 메시지 만이 아니라 해당 파일에 모든 로그 메시지가 추가됩니다. – CSharpAtl

+0

그래서 우리는 'ResetConfiguration'을 호출했습니다 ... – AwkwardCoder

+0

하지만 지금은 앱 퍼더가 1 개 뿐이며 앱에 다른 것들이 기록되어야한다면 새로운 파일에 기록 될 것입니다 ... 이 프로세스의 로깅을 새 파일로 이동하고 일반 로그 파일의 다른 모든 로깅 만 필요합니다. – CSharpAtl

1

좋아하는 방법 당신은 또한으로 IDisposable을 구현하는 ILOG 인터페이스의 사용자 지정 구현을 만들에 대해 -을 appender가 생성되면 추가하고 삭제되었을 때 제거하십시오 ...

예.

class Program 
{ 
    static void Main(string[] args) 
    { 
     log4net.Config.BasicConfigurator.Configure(); 

     var file = Path.Combine(Directory.GetCurrentDirectory(), Guid.NewGuid() + ".log"); 
     using (var log = new CustomFileLogger(file)) 
     { 
      // Process file... 
      log.Info("file: Made it here!"); 
      log.Error("file: Made it here!"); 
     } 

     var file2 = Path.Combine(Directory.GetCurrentDirectory(), Guid.NewGuid() + ".log"); 
     using (var log = new CustomFileLogger(file2)) 
     { 
      // Process file... 
      log.Info("file2: Made it here!"); 
      log.Error("file2: Made it here!"); 
     } 
    } 
} 

public sealed class CustomFileLogger : ILog, IDisposable 
{ 
    private ILog _log; 
    private FileAppender _appender; 
    private string _file; 

    public CustomFileLogger(string file) 
    { 
     _file = file; 

     var hierarchy = (Hierarchy)LogManager.GetRepository(); 
     hierarchy.Configured = false; 

     var patternLayout = new PatternLayout(); 
     patternLayout.ConversionPattern = "%d [%t] %-5p %c [%x] - %m%n"; 
     patternLayout.ActivateOptions(); 

     var appender = new FileAppender { File = file, AppendToFile = true, Layout = patternLayout }; 
     appender.ActivateOptions(); 

     var logger = (Logger)hierarchy.GetLogger(file); 
     logger.AddAppender(appender); 

     hierarchy.Configured = true; 
     _log = LogManager.GetLogger(file); 
    } 

    public ILogger Logger 
    { 
     get { return _log.Logger; } 
    } 

    public void Dispose() 
    { 
     var hierarchy = (Hierarchy)LogManager.GetRepository(); 
     hierarchy.Configured = false; 

     var logger = (Logger)hierarchy.GetLogger(_file); 
     logger.RemoveAppender(_appender); 

     hierarchy.Configured = false; 


     _appender = null; 
     _log = null; 
     _file = null; 
    } 

    public void Debug(object message) 
    { 
     _log.Debug(message); 
    } 

    public void Debug(object message, Exception exception) 
    { 
     _log.Debug(message, exception); 
    } 

    public void DebugFormat(string format, params object[] args) 
    { 
     _log.DebugFormat(format, args); 
    } 

    public void DebugFormat(string format, object arg0) 
    { 
     _log.DebugFormat(format, arg0); 
    } 

    public void DebugFormat(string format, object arg0, object arg1) 
    { 
     _log.DebugFormat(format, arg0, arg1); 
    } 

    public void DebugFormat(string format, object arg0, object arg1, object arg2) 
    { 
     _log.DebugFormat(format, arg0, arg1, arg2); 
    } 

    public void DebugFormat(IFormatProvider provider, string format, params object[] args) 
    { 
     _log.DebugFormat(provider, format, args); 
    } 

    public void Info(object message) 
    { 
     _log.Info(message); 
    } 

    public void Info(object message, Exception exception) 
    { 
     _log.Info(message, exception); 
    } 

    public void InfoFormat(string format, params object[] args) 
    { 
     _log.InfoFormat(format, args); 
    } 

    public void InfoFormat(string format, object arg0) 
    { 
     _log.InfoFormat(format, arg0); 
    } 

    public void InfoFormat(string format, object arg0, object arg1) 
    { 
     _log.InfoFormat(format, arg0, arg1); 
    } 

    public void InfoFormat(string format, object arg0, object arg1, object arg2) 
    { 
     _log.InfoFormat(format, arg0, arg1, arg2); 
    } 

    public void InfoFormat(IFormatProvider provider, string format, params object[] args) 
    { 
     _log.InfoFormat(provider, format, args); 
    } 

    public void Warn(object message) 
    { 
     _log.Warn(message); 
    } 

    public void Warn(object message, Exception exception) 
    { 
     _log.Warn(message, exception); 
    } 

    public void WarnFormat(string format, params object[] args) 
    { 
     _log.WarnFormat(format, args); 
    } 

    public void WarnFormat(string format, object arg0) 
    { 
     _log.WarnFormat(format, arg0); 
    } 

    public void WarnFormat(string format, object arg0, object arg1) 
    { 
     _log.WarnFormat(format, arg0, arg1); 
    } 

    public void WarnFormat(string format, object arg0, object arg1, object arg2) 
    { 
     _log.WarnFormat(format, arg0, arg1, arg2); 
    } 

    public void WarnFormat(IFormatProvider provider, string format, params object[] args) 
    { 
     _log.WarnFormat(provider, format, args); 
    } 

    public void Error(object message) 
    { 
     _log.Error(message); 
    } 

    public void Error(object message, Exception exception) 
    { 
     _log.Error(message, exception); 
    } 

    public void ErrorFormat(string format, params object[] args) 
    { 
     _log.ErrorFormat(format, args); 
    } 

    public void ErrorFormat(string format, object arg0) 
    { 
     _log.ErrorFormat(format, arg0); 
    } 

    public void ErrorFormat(string format, object arg0, object arg1) 
    { 
     _log.ErrorFormat(format, arg0, arg1); 
    } 

    public void ErrorFormat(string format, object arg0, object arg1, object arg2) 
    { 
     _log.ErrorFormat(format, arg0, arg1, arg2); 
    } 

    public void ErrorFormat(IFormatProvider provider, string format, params object[] args) 
    { 
     _log.ErrorFormat(provider, format, args); 
    } 

    public void Fatal(object message) 
    { 
     _log.Fatal(message); 
    } 

    public void Fatal(object message, Exception exception) 
    { 
     _log.Fatal(message, exception); 
    } 

    public void FatalFormat(string format, params object[] args) 
    { 
     _log.FatalFormat(format, args); 
    } 

    public void FatalFormat(string format, object arg0) 
    { 
     _log.FatalFormat(format, arg0); 
    } 

    public void FatalFormat(string format, object arg0, object arg1) 
    { 
     _log.FatalFormat(format, arg0, arg1); 
    } 

    public void FatalFormat(string format, object arg0, object arg1, object arg2) 
    { 
     _log.FatalFormat(format, arg0, arg1, arg2); 
    } 

    public void FatalFormat(IFormatProvider provider, string format, params object[] args) 
    { 
     _log.FatalFormat(provider, format, args); 
    } 

    public bool IsDebugEnabled 
    { 
     get { return _log.IsDebugEnabled; } 
    } 

    public bool IsInfoEnabled 
    { 
     get { return _log.IsInfoEnabled; } 
    } 

    public bool IsWarnEnabled 
    { 
     get { return _log.IsWarnEnabled; } 
    } 

    public bool IsErrorEnabled 
    { 
     get { return _log.IsErrorEnabled; } 
    } 

    public bool IsFatalEnabled 
    { 
     get { return _log.IsFatalEnabled; } 
    } 
} 
1

매우 쉽게 할 수 있지만 인터페이스가 아닌 특정 구현에 자신을 묶는 것을 의미합니다. 예를 들면 다음과 같습니다 펜더으로

log4net.ILog log = log4net.LogManager.GetLogger(loggerName); 
log4net.Repository.Hierarchy.Logger logImpl = log.Logger as log4net.Repository.Hierarchy.Logger; 
if (logImpl != null) 
    logImpl.AddAppender(uploadLogAppender); 
else { 
    // unexpected logger type - handle this case somehow 
} 
ProcessUpload(); // does logging 
if (logImpl != null) 
    logImpl.RemoveAppender(uploadLogAppender); 

ProcessUpload 실행, 이것은 당신이 필요로하는 효과를 제공한다 동안에 만 존재합니다. uploadLogAppender은 사용자가 지정한 파일 이름 (예 : 업로드 기준)을 가진 FileAppender 인스턴스입니다.

관련 문제