Eu estava procurando uma maneira de registrar nomes de classes e métodos como parte da minha infraestrutura de log. Obviamente, gostaria de simplificar o uso e acelerar o tempo de execução. Eu li muito sobre o registro de nomes de classes e métodos, mas me deparei com dois temas.

Esse log4net usa uma exceção lançada internamente para gerar um quadro de pilha e fica caro se você o usar geralmente para todos os logs.Confusão. Há muita literatura por aí. Eu tentei um monte e não cheguei a algo útil.

Se você me zoar por um segundo, eu gostaria de redefinir.

Eu criei uma classe como esta no meu projeto

public static class Log {
    private static Dictionary<Type, ILog> _loggers = new Dictionary<Type, ILog>();
    private static bool _logInitialized = false;
    private static object _lock = new object();

    public static string SerializeException(Exception e) {
        return SerializeException(e, string.Empty);
    }

    private static string SerializeException(Exception e, string exceptionMessage) {
        if (e == null) return string.Empty;

        exceptionMessage = string.Format(
            "{0}{1}{2}\n{3}",
            exceptionMessage,
            (exceptionMessage == string.Empty) ? string.Empty : "\n\n",
            e.Message,
            e.StackTrace);

        if (e.InnerException != null)
            exceptionMessage = SerializeException(e.InnerException, exceptionMessage);

        return exceptionMessage;
    }

    private static ILog getLogger(Type source) {
        lock (_lock) {
            if (_loggers.ContainsKey(source)) {
                return _loggers[source];
            }

            ILog logger = log4net.LogManager.GetLogger(source);
            _loggers.Add(source, logger);
            return logger;
        }
    }

    public static void Debug(object source, object message) {
        Debug(source.GetType(), message);
    }

    public static void Debug(Type source, object message) {
        getLogger(source).Debug(message);
    }

    public static void Info(object source, object message) {
        Info(source.GetType(), message);
    }

    public static void Info(Type source, object message) {
        getLogger(source).Info(message);
    }

...

    private static void initialize() {
        XmlConfigurator.Configure(); 
    }

    public static void EnsureInitialized() {
        if (!_logInitialized) {
            initialize();
            _logInitialized = true;
        }
    }
}

(Se esse código parece familiar, é porque foi emprestado dos exemplos!)

De qualquer forma, em todo o meu projeto eu uso as linhas li, ke isto para registrar:

        Log.Info(typeof(Program).Name, "System Start");

Bem, este tipo de obras. Mais importante, recebo o nome da classe, mas não o nome do método. Menos importante, estou poluindo meu código com esse "tipo de lixo". Se eu copiar e colar um trecho de código entre arquivos, etc., a estrutura de log estará mentindo!

Eu tentei brincar com o PatternLayout (% C {1}. {M}), mas isso não funcionou (tudo o que ele fez foi gravar "Log.Info" no log - porque tudo está sendo roteado pelos métodos estáticos do Log.X !). Além disso, isso deve ser lento.

Então, qual é a melhor maneira, dada a minha configuração e meu desejo de ser simples e rápido?

Agradeço antecipadamente qualquer ajuda.