C# log4net…单独的日志文件

每次我在WCF服务中执行某个流程时，我都会写一个单独的日志。我已经使用log4net为整个应用程序创建了一个标准日志。我是否应该为特定进程添加一个appender和过滤器，然后将其删除？此过程处理已上载的文件的处理。还有其他想法吗？

我以前做过类似的事情，我们使用了如下代码：

奥利

---

好的，你创建了一个ILog接口的自定义实现，它也实现了IDisposable，你在创建appender时添加它，在释放它时删除它

例如

---

您可以很容易地做到这一点，但这意味着将自己绑定到特定的实现，而不是接口。例如：

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

---

由于appender仅在

ProcessUpload

运行时才出现，因此这将为您提供所需的效果

uploadLogAppender

只是一个

FileAppender

实例，其文件名由您确定，比如每次上载。

我遇到的问题，我的问题可能不清楚。我在上传后运行一个文件，我想要一个日志文件，用于文件的每次处理。如果添加一个appender并且不使用过滤器，我也会将所有日志消息添加到该文件中，而不仅仅是处理一个文件的消息。但这意味着现在我只有一个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; }
    }
}

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