Ich habe nach einer Möglichkeit gesucht, Klassennamen und Methodennamen als Teil meiner Protokollierungsinfrastruktur zu protokollieren. Natürlich möchte ich es zur Laufzeit einfach und schnell machen. Ich habe viel über das Protokollieren von Klassennamen und Methodennamen gelesen, bin aber auf zwei Themen gestoßen.

Das log4net verwendet eine intern ausgelöste Ausnahme, um einen Stack-Frame zu generieren, und das wird teuer, wenn Sie diese generell für die gesamte Protokollierung verwenden.Verwechslung. Es gibt eine Menge Literatur. Ich habe ein paar davon ausprobiert und bin nicht zu etwas Nützlichem gekommen.

Wenn du mich für eine Sekunde humorst, würde ich gerne zurücksetzen.

Ich habe eine Klasse wie diese in meinem Projekt erstellt

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

(Wenn dieser Code bekannt vorkommt, liegt es daran, dass er aus den Beispielen entlehnt wurde!)

In jedem Fall benutze ich in meinem Projekt die Zeilen li, ke this um zu protokollieren:

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

Nun, diese Art von Arbeiten. Am wichtigsten ist, ich bekomme den Klassennamen, aber keinen Methodennamen. Weniger wichtig ist, dass ich meinen Code mit diesem "Typ von" Müll verschmutze. Wenn ich einen Codeausschnitt zwischen Dateien usw. kopiere und einfüge, lügt das Protokollierungsframework!

Ich habe versucht, mit dem PatternLayout (% C {1}. {M}) zu spielen, aber das hat nicht funktioniert (alles, was es getan hat, war, "Log.Info" in das Protokoll zu schreiben - weil alles über die statische Datei Log.X geleitet wird Methoden!). Außerdem soll das langsam sein.

So, was ist der beste Weg angesichts meines Setups und meines Wunsches, einfach und schnell zu sein?

Schätzen Sie Hilfe im Voraus.