Protokollierung ein-und Ausfahrt von Methoden zusammen mit den Parametern automatisch?

Ist es für mich ein Weg, um fügen Sie die Protokollierung, so dass das betreten und verlassen von Methoden wird protokolliert zusammen mit den Parametern automatisch irgendwie für tracing-Zwecke? Wie würde ich tun?

Ich bin mit Log4Net.

InformationsquelleAutor Xerx | 2008-10-05
  1. 7

    Der beste Weg, um erreichen diese Art der Sache wird durch die Verwendung abfangen, Es gibt ein paar Möglichkeiten, dies zu tun, aber Sie alle neigen dazu, etwas invasiv. Da wäre zum einen leiten Sie alle Ihre Objekte aus ContextBoundObject. Hier ist ein Beispiel für die Verwendung dieses Ansatzes. Der andere Ansatz wäre die Verwendung einer der bestehenden AOP-Bibliotheken zu erreichen. So etwas wie DynamicProxy aus der Schloss-Projekt ist der Kern vieler dieser. Hier sind ein paar links:
    Spring.Net
    PostSharp
    Cecil

    Gibt es wahrscheinlich mehrere andere, und ich weiß,Schloss Windsor, und Ninject sowohl die AOP-Funktionen auf der Oberseite des IoC-Funktionalität.

    Einmal AOP ist in Ort, den Sie würde einfach schreiben Sie eine interceptor-Klasse, würde schreiben, die Informationen über die Methode ruft log4net.

    Ich eigentlich nicht überraschen würde, wenn einer der AOP-frameworks würde Ihnen die Art von Funktionalität aus der box.

    InformationsquelleAutor ckramer
  2. 4

    Ich bin mir nicht sicher, was Ihre tatsächlichen Bedürfnisse sind, aber hier ist ein low-rent-option. Es ist nicht gerade das "automatische", aber man könnte StackTrace zu schälen die Informationen, die Sie suchen, in einer Weise, die nicht verlangen, Argumente übergeben - ähnlich wie ckramer ' s Vorschlag bezüglich abfangen:

    using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

using System.Diagnostics;

namespace TracingSample
{
    class Program
    {
        static void Main(string[] args)
        {
            DoSomething();
        }

        static void DoSomething()
        {
            LogEnter();

            Console.WriteLine("Executing DoSomething");

            LogExit();
        }

        static void LogEnter()
        {
            StackTrace trace = new StackTrace();
            if (trace.FrameCount > 1)
            {
                string ns = trace.GetFrame(1).GetMethod().DeclaringType.Namespace;
                string typeName = trace.GetFrame(1).GetMethod().DeclaringType.Name;
                Console.WriteLine("Entering {0}.{1}.{2}", ns, typeName, trace.GetFrame(1).GetMethod().Name);
            }
        }

        static void LogExit()
        {
            StackTrace trace = new StackTrace();
            if (trace.FrameCount > 1)
            {
                string ns = trace.GetFrame(1).GetMethod().DeclaringType.Namespace;
                string typeName = trace.GetFrame(1).GetMethod().DeclaringType.Name;
                Console.WriteLine("Exiting {0}.{1}.{2}", ns, typeName, trace.GetFrame(1).GetMethod().Name);
            }
        }
    }
}

    Könnte man kombinieren, so etwas wie das obige Beispiel mit der Vererbung, mit einem nicht-virtuellen öffentliche Element im Basis-Typ, zu bedeuten, dass die action-Methode, dann Aufruf einer virtuellen Mitglied, um die eigentliche Arbeit:

    public abstract class BaseType
{
    public void SomeFunction()
    {

        LogEnter();
        DoSomeFunction();
        LogExit();
    }

    public abstract void DoSomeFunction();
}

public class SubType : BaseType
{
    public override void DoSomeFunction()
    {
        //Implementation of SomeFunction logic here...
    }
}

    Wieder - es gibt nicht viel "automatisch" über dieses, aber es würde die Arbeit auf einer begrenzten basis, wenn Sie nicht verlangen, instrumentation, die auf jeden einzelnen Methodenaufrufs.

    Hoffe, das hilft.

    • Dieser code geht auch mit diesem code erfassen Sie die parameter-Werte von stackoverflow.com/a/6928253/1267778 . Also ich habe so etwas wie logService.LogEnter(arg1, arg2, arg3). Tolle Sachen
    InformationsquelleAutor Jared
  3. 4

    Haben Sie einen Blick auf:

    Wie kann ich abfangen des Aufrufs einer Methode in C#?
    PostSharp - il Weberei - Gedanken

    Suche auch SO für 'AOP' oder 'Aspect-Oriented Programming' und PostSharp...Sie erhalten einige interessante Ergebnisse.

    InformationsquelleAutor Kev
  4. 3

    Könnten Sie einen post-compiler wie Postsharp. Das Beispiel von der website spricht über die Einrichtung eines tracer für das betreten und verlassen einer Methode, die sehr ähnlich zu dem, was Sie wollen.

    InformationsquelleAutor Cameron MacFarland
  6. 0

    Können Sie open-source-framework CInject auf CodePlex hat eine LogInjector zu markieren Sie den Eintrag und beenden des Aufrufs einer Methode.

    Oder können Sie die genannten Schritte auf diesem Artikel auf Das abfangen der Methodenaufrufe mit IL und erstellen Sie Ihre eigenen Abfangjäger mit der Spiegelung.Strahlen-Klassen in C#.

    InformationsquelleAutor Puneet Ghanshani
  7. 0

    Funktionen

    Erweitern auf Jareds Antwort, die Vermeidung von code-Wiederholung und darunter Optionen für Argumente:

    private static void LogEnterExit(bool isEnter = true, params object[] args)
{
    StackTrace trace = new StackTrace(true);  //need `true` for getting file and line info
    if (trace.FrameCount > 2)
    {
        string ns = trace.GetFrame(2).GetMethod().DeclaringType.Namespace;
        string typeName = trace.GetFrame(2).GetMethod().DeclaringType.Name;
        string args_string = args.Length == 0 ? "" : "\narguments: [" + args.Aggregate((current, next) => string.Format("{0},{1};", current, next))+"]";
        Console.WriteLine("{0} {1}.{2}.{3}{4}", isEnter ? "Entering" : "Exiting", ns, typeName, trace.GetFrame(2).GetMethod().Name, args_string );
    }
}

static void LogEnter(params object[] args)
{
    LogEnterExit(true, args);
}

static void LogExit(params object[] args)
{
    LogEnterExit(false, args);
}

    Nutzung

    static void DoSomething(string arg1)
{
    LogEnter(arg1);
    Console.WriteLine("Executing DoSomething");
    LogExit();
}

    Ausgang

    In der Konsole, das wäre der Ausgang, wenn DoSomething ausgeführt wurden, mit "bla" als arg1

    Entering Program.DoSomething
arguments: [blah]
Executing DoSomething
Exiting Program.DoSomething
    InformationsquelleAutor Kyle Falconer
Schreibe einen Kommentar