edit: Einige Hintergrund
Wir haben eine ähnliche Funktion haben, die 99% der Zeit deaktiviert ist; wir wurden mit einem Ansatz wie:
public void DoSomething()
{
TraceCall(MethodBase.GetCurrentMethod().Name);
// Do Something
}
public void TraceCall(string methodName)
{
if (!loggingEnabled) { return; }
// Log...
}
TraceCall(MethodBase.GetCurrentMethod().Name)
Es war einfach, aber unabhängig davon, ob oder nicht, wurde Tracing aktiviert wir die Performance-Einbußen Reflection wurden entstehen für die Verwendung der Methode Namen nachzuschlagen.
waren unsere Optionen entweder zu mehr Code in jeder Methode (und Risiko einfache Fehler oder Verweigerung) oder wechseln zu verwenden StackFrame erfordern die Rufmethode nur wenn die Protokollierung aktiviert wurde, um zu bestimmen.
Option A:
public void DoSomething()
{
if (loggingEnabled)
{
TraceCall(MethodBase.GetCurrentMethod().Name);
}
// Do Something
}
public void TraceCall(string methodName)
{
if (!loggingEnabled) { return; }
// Log...
}
Option B:
public void DoSomething()
{
TraceCall();
// Do Something
}
public void TraceCall()
{
if (!loggingEnabled) { return; }
StackFrame stackFrame = new StackFrame(1);
// Log...
}
Wir für Option B entschieden es erhebliche Leistungsverbesserungen gegenüber Option bietet ein bei der Anmeldung deaktiviert ist, 99% der Zeit und ist sehr einfach zu implementieren.
Hier ist eine Änderung von Michaels Code,
die Kosten/Nutzen dieses Ansatzes anzuzeigen
using System;
using System.Diagnostics;
using System.Reflection;
namespace ConsoleApplication
{
class Program
{
static bool traceCalls;
static void Main(string[] args)
{
Stopwatch sw;
// warm up
for (int i = 0; i < 100000; i++)
{
TraceCall();
}
// call 100K times, tracing *disabled*, passing method name
sw = Stopwatch.StartNew();
traceCalls = false;
for (int i = 0; i < 100000; i++)
{
TraceCall(MethodBase.GetCurrentMethod());
}
sw.Stop();
Console.WriteLine("Tracing Disabled, passing Method Name: {0}ms"
, sw.ElapsedMilliseconds);
// call 100K times, tracing *enabled*, passing method name
sw = Stopwatch.StartNew();
traceCalls = true;
for (int i = 0; i < 100000; i++)
{
TraceCall(MethodBase.GetCurrentMethod());
}
sw.Stop();
Console.WriteLine("Tracing Enabled, passing Method Name: {0}ms"
, sw.ElapsedMilliseconds);
// call 100K times, tracing *disabled*, determining method name
sw = Stopwatch.StartNew();
traceCalls = false;
for (int i = 0; i < 100000; i++)
{
TraceCall();
}
Console.WriteLine("Tracing Disabled, looking up Method Name: {0}ms"
, sw.ElapsedMilliseconds);
// call 100K times, tracing *enabled*, determining method name
sw = Stopwatch.StartNew();
traceCalls = true;
for (int i = 0; i < 100000; i++)
{
TraceCall();
}
Console.WriteLine("Tracing Enabled, looking up Method Name: {0}ms"
, sw.ElapsedMilliseconds);
Console.ReadKey();
}
private static void TraceCall()
{
if (traceCalls)
{
StackFrame stackFrame = new StackFrame(1);
TraceCall(stackFrame.GetMethod().Name);
}
}
private static void TraceCall(MethodBase method)
{
if (traceCalls)
{
TraceCall(method.Name);
}
}
private static void TraceCall(string methodName)
{
// Write to log
}
}
}
Die Ergebnisse:
Tracing Disabled, passing Method Name: 294ms
Tracing Enabled, passing Method Name: 298ms
Tracing Disabled, looking up Method Name: 0ms
Tracing Enabled, looking up Method Name: 1230ms
Vorsicht, es gibt einen SO-Bot, der alle Fragen beantwortet: Probieren Sie es aus! – harpo
Wird diese Protokollierung immer aktiviert? Was ist der alternative Ansatz? Michaels Ergebnisse sind interessant, aber die eigentliche Frage ist: "Wie kommt dieser Ansatz zu X?" – STW
@Yoooder: gute Fragen. Ich denke, das "X", mit dem wir das vergleichen, ist die Protokollierung ohne Methodeninformationen oder mit statisch generierten Methodeninformationen. "Sollte ich es deaktivieren?": Testen Sie in Ihrer Anwendung, und sehen Sie, ob die Leistungsunterschiede messbar oder bemerkbar sind. –