Comment effectuer le suivi de chaque méthode appelée

Vous pouvez faire cela avec L'Unité D'Interception

Voir ce article pour un exemple. L'article utilise des attributs, mais mon exemple de code ci-dessous utilise l'injection de dépendance (système de codage à une interface) pour l'installation d'interception.

Si vous souhaitez vous connecter MyClass, il va quelque chose comme ceci:

1. Faire une interface qui contient toutes les méthodes dans MyClass => IMyClass
2. Vous installation InterfaceInterception (comme je l'ai fait ci-dessous) OU il ya quelques autres façons que vous pouvez configurer. Voir ici pour toutes les options.
3. Vous aurez la configuration d'une politique d'intercepter toutes les méthodes qui correspond à IMatchingRule.
4. Tous les appels maintenant être intercepté par votre ICallHandler mise en œuvre.

Code:

//You  will use the code like this:
MyContainer container = new MyContainer();
//setup interception for this type..
container.SetupForInteception(typeof(IMyClass));
 //what happens here is you get a proxy class 
 //that intercepts every method call.
IMyClass cls = container.Resolve<IMyClass>();

 //You need the following for it to work:   
public class MyContainer: UnityContainer
{
    public MyContainer()
    {
        this.AddNewExtension<Interception>();
        this.RegisterType(typeof(ICallHandler), 
                    typeof(LogCallHandler), "MyCallHandler");
        this.RegisterType(typeof(IMatchingRule), 
                       typeof(AnyMatchingRule), "AnyMatchingRule");

        this.RegisterType<IMyClass, MyClass>();
    }
    //apparently there is a new way to do this part
    //http://msdn.microsoft.com/en-us/library/ff660911%28PandP.20%29.aspx

    public void SetupForInteception(Type t)
    {
        this.Configure<Interception>()
        .SetInterceptorFor(t, new InterfaceInterceptor())
        .AddPolicy("LoggingPolicy")
        .AddMatchingRule("AnyMatchingRule")
        .AddCallHandler("MyCallHandler");

    }
}
//THIS will match which methods to log.
public class AnyMatchingRule : IMatchingRule
{
    public bool Matches(MethodBase member)
    {
        return true;//this ends up loggin ALL methods.
    }
}
public class LogCallHandler : ICallHandler
{
    public IMethodReturn 
             Invoke(IMethodInvocation input, GetNextHandlerDelegate getNext)
    {
      //All method calls will result in a call here FIRST.
      //IMethodInvocation has an exception property which will let you know
      //if an exception occurred during the method call.
    }
 }

PostSharp offre certainement un moyen d'appliquer un aspect à plusieurs cibles sans les décorant avec des attributs explicitement. Voir Multidiffusion attributs.

Lors de l'élaboration (multicast) aspect vous devez spécifier son utilisation:

[MulticastAttributeUsage(MulticastTargets.Method, TargetMemberAttributes = MulticastAttributes.Instance)]
[AttributeUsage(AttributeTargets.Assembly|AttributeTargets.Class|AttributeTargets.Method, AllowMultiple = true)]
[Serializable]
public class TraceAttribute : MethodInterceptionAspect
{
//Details skipped.
}

Et ensuite appliquer l'aspect d'une manière qui couvre votre cas d'utilisation (par exemple. tous les membres du public dans la base de données AdventureWorks.BusinessLayer espace de noms):

[assembly: Trace( AttributeTargetTypes="AdventureWorks.BusinessLayer.*", AttributeTargetMemberAttributes = MulticastAttributes.Public )]