La journalisation d'entrée et de sortie de méthodes ainsi que les paramètres automatiquement?

Est-il un moyen pour moi d'ajouter les journaux de sorte que l'entrée et à la sortie des méthodes obtient connecté avec automatiquement les paramètres d'une certaine manière à des fins de traçabilité? Comment pourrais-je le faire?

Je suis à l'aide de Log4Net.

OriginalL'auteur Xerx | 2008-10-05

  1. 7

    Le meilleur moyen de réaliser ce genre de chose est à l'aide de l'interception, Il ya un couple de façons de le faire, mais ils ont tous tendance à être un peu envahissantes. On serait à dériver tous vos objets de ContextBoundObject. Ici est un exemple de l'utilisation de ce type de démarche. L'autre approche serait d'utiliser l'un de ces AOP bibliothèques pour y parvenir. Quelque chose comme DynamicProxy de la Château De Projet est au cœur de bon nombre de ces. Voici quelques liens:
    Spring.Net
    PostSharp
    Cecil

    Il y a probablement plusieurs autres, et je sais Le Château De Windsor, et Ninject à la fois fournir des AOP les capacités de la Coi fonctionnalité.

    Une fois que l'AOP est en place, vous pouvez tout simplement écrire un intercepteur de classe qui permettrait d'écrire les informations sur les appels de méthode à log4net.

    En fait je ne serais pas surpris si l'un des AOP cadres de vous donner ce genre de fonctionnalité de la boîte.

    OriginalL'auteur ckramer

  2. 4

    Je ne suis pas sûr de ce que vos besoins réels, mais ici, c'est un faible loyer de l'option. Ce n'est pas exactement "automatique", mais vous pouvez utiliser le StackTrace à peler les informations que vous recherchez une manière qui ne serait pas la demande de passage des arguments similaires à ckramer est une suggestion au sujet de l'interception:

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

    Vous pouvez combiner quelque chose comme l'exemple ci-dessus avec l'héritage, à l'aide d'un non-virtuel membre du public dans le type de base pour signifier la méthode de l'action, puis de l'appel d'un membre virtuel de le faire réellement le travail:

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

    De nouveau - il n'y a pas beaucoup de "automatique" à ce sujet, mais il serait de travailler sur une base limitée, si vous n'avez pas besoin de l'instrumentation sur chaque invocation de méthode.

    Espère que cette aide.

    Ce code va bien avec ce code pour capturer les valeurs de paramètre stackoverflow.com/a/6928253/1267778 . Donc, j'ai quelque chose comme logService.LogEnter(arg1, arg2, arg3). Great stuff

    OriginalL'auteur Jared

  3. 4

    Jeter un oeil à:

    Comment faire pour intercepter un appel de méthode en C#?
    PostSharp - il - le tissage de pensées

    Aussi une recherche pour " AOP " ou "la Programmation Orientée Aspects" et PostSharp...vous obtenez des résultats intéressants.

    OriginalL'auteur Kev

  4. 3

    Vous pourriez utiliser un post-compilateur comme Postsharp. L'échantillon à partir du site web de pourparlers sur la configuration d'un traceur pour l'entrée/la sortie d'une méthode, qui est très similaire à ce que vous voulez.

    OriginalL'auteur Cameron MacFarland

  5. 0

    La Décorateur Modèle peut aider.

    OriginalL'auteur Vivek Kodira

  6. 0

    Vous pouvez utiliser le framework open source CInject sur CodePlex qui a un LogInjector pour marquer l'entrée et la sortie d'un appel de méthode.

    Ou vous pouvez suivre les étapes mentionnées sur cet article sur Intercepter les Appels de Méthode à l'aide de l'IL et de créer votre propre intercepteur l'aide de la Réflexion.Émettent des classes en C#.

    OriginalL'auteur Puneet Ghanshani

  7. 0

    Fonctions

    Étendre sur Jared réponse, en évitant la répétition de code et notamment options pour les arguments:

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

    Utilisation

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

    Sortie

    Dans la console, ce serait la sortie si les DoSomething ont été exécutés avec "bla" comme arg1

    Entering Program.DoSomething
arguments: [blah]
Executing DoSomething
Exiting Program.DoSomething

    OriginalL'auteur Kyle Falconer