Comment puis-je ajouter une Trace() à chaque appel de méthode en C#?

Probablement votre meilleur pari serait d'utiliser un AOP (aspect oriented programming) cadre pour appeler automatiquement le traçage de code avant et après l'exécution de la méthode. Un choix populaire pour les AOP et .NET est PostSharp.

Si votre objectif principal est de la fonction log de points d'entrée/sortie et d'occasion, de l'information entre les deux, j'ai eu de bons résultats avec une Jetables la journalisation de l'objet où le constructeur traces d'entrée de la fonction, et Dispose() retrace la sortie. Cela permet d'appeler le code de simplement envelopper chaque méthode de code à l'intérieur d'un seul à l'aide de déclaration. Les méthodes sont également fournis pour arbitraire journaux entre les deux. Voici une complète C# ETW suivi des événements de classe avec une fonction d'entrée/sortie wrapper:

using System;
using System.Diagnostics;
using System.Diagnostics.Tracing;
using System.Reflection;
using System.Runtime.CompilerServices;
namespace MyExample
{
//This class traces function entry/exit
//Constructor is used to automatically log function entry.
//Dispose is used to automatically log function exit.
//use "using(FnTraceWrap x = new FnTraceWrap()){ function code }" pattern for function entry/exit tracing
public class FnTraceWrap : IDisposable
{
string methodName;
string className;
private bool _disposed = false;
public FnTraceWrap()
{
StackFrame frame;
MethodBase method;
frame = new StackFrame(1);
method = frame.GetMethod();
this.methodName = method.Name;
this.className = method.DeclaringType.Name;
MyEventSourceClass.Log.TraceEnter(this.className, this.methodName);
}
public void TraceMessage(string format, params object[] args)
{
string message = String.Format(format, args);
MyEventSourceClass.Log.TraceMessage(message);
}
public void Dispose()
{
if (!this._disposed)
{
this._disposed = true;
MyEventSourceClass.Log.TraceExit(this.className, this.methodName);
}
}
}
[EventSource(Name = "MyEventSource")]
sealed class MyEventSourceClass : EventSource
{
//Global singleton instance
public static MyEventSourceClass Log = new MyEventSourceClass();
private MyEventSourceClass()
{
}
[Event(1, Opcode = EventOpcode.Info, Level = EventLevel.Informational)]
public void TraceMessage(string message)
{
WriteEvent(1, message);
}
[Event(2, Message = "{0}({1}) - {2}: {3}", Opcode = EventOpcode.Info, Level = EventLevel.Informational)]
public void TraceCodeLine([CallerFilePath] string filePath = "",
[CallerLineNumber] int line = 0,
[CallerMemberName] string memberName = "", string message = "")
{
WriteEvent(2, filePath, line, memberName, message);
}
//Function-level entry and exit tracing
[Event(3, Message = "Entering {0}.{1}", Opcode = EventOpcode.Start, Level = EventLevel.Informational)]
public void TraceEnter(string className, string methodName)
{
WriteEvent(3, className, methodName);
}
[Event(4, Message = "Exiting {0}.{1}", Opcode = EventOpcode.Stop, Level = EventLevel.Informational)]
public void TraceExit(string className, string methodName)
{
WriteEvent(4, className, methodName);
}
}
}

Code qui utilise il ressemblera à quelque chose comme ceci:

public void DoWork(string foo)
{
using (FnTraceWrap fnTrace = new FnTraceWrap())
{
fnTrace.TraceMessage("Doing work on {0}.", foo);
/*
code ...
*/
}
}

Il pourrait être en attente pour le verrouillage de problème à prendre en main, de faire un vidage de la mémoire et de l'analyse de la pile d'appel sur les différents threads. Vous pouvez utiliser DebugDiag ou le adplus de script (se bloquer en mode, dans ce cas) qui vient avec Les Outils de débogage pour Windows.

Tess Ferrandez a aussi un excellent laboratoire de la série sur l'apprentissage de débogage diverses questions à l'aide .NET les vidages de mémoire. Je le recommande fortement.