He estado buscando una forma de registrar nombres de clases y nombres de métodos como parte de mi infraestructura de registro. Obviamente, me gustaría que sea fácil de usar y rápido en tiempo de ejecución. He leído mucho sobre el registro de nombres de clases y nombres de métodos, pero me he encontrado con 2 temas.

Ese log4net usa una excepción de lanzamiento interno para generar un marco de pila y eso se vuelve costoso si lo usa generalmente para todos los registros.Confusión. Hay mucha literatura por ahí. He probado un montón y no he llegado a algo útil.

Si me haces el favor por un segundo, me gustaría reiniciar.

Creé una clase como esta en mi proyecto

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

(¡Si este código parece familiar es porque está tomado de los ejemplos!)

En cualquier caso, a lo largo de mi proyecto uso líneas li, ke esto para registrar:

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

Bueno, este tipo de trabajos. Lo más importante, obtengo el nombre de la clase pero no el nombre del método. Menos importante, estoy contaminando mi código con esta basura "typeof". Si copio y pego un fragmento de código entre archivos, etc., el marco de registro estará mintiendo.

Intenté jugar con PatternLayout (% C {1}. {M}) pero eso no funcionó (todo lo que hizo fue escribir "Log.Info" en el registro, porque todo se enruta a través de los métodos estáticos Log.X !). Además, se supone que eso es lento.

Entonces, ¿cuál es la mejor manera, dada mi configuración y mi deseo de ser simple y rápido?

Agradezco cualquier ayuda por adelantado.