PostSharp - il weaving - pensées

Question

Je considère l'utilisation du framework Postsharp pour alléger le fardeau de la journalisation de la méthode d'application. Cela me permet essentiellement d'orner les méthodes avec l'attribut de journalisation et au moment de la compilation injecte le code de journalisation nécessaire dans le il. J'aime cette solution car elle empêche le bruit de sortir de l'environnement du code temporel. Des pensées, des expériences ou de meilleures alternatives?

Answer 1

J'applique la journalisation avec AOP en utilisant Castle Windsor DynamicProxies. J'utilisais déjà Castle pour son conteneur IoC, donc l'utiliser pour AOP était le chemin de moindre résistance pour moi. Si vous voulez plus d'info laissez-moi savoir, je suis en train de ranger le code pour le libérer comme un billet de blog

Modifier

Ok, voici le code Intercepter de base, faily de base, mais il fait tout J'ai besoin. Il y a deux intercepters, un journal everyhing et l'autre vous permet de définir des noms de méthodes pour permettre une journalisation plus fine. Cette solution dépend faily sur le château de Windsor

Résumé classe de base

namespace Tools.CastleWindsor.Interceptors 
{ 
using System; 
using System.Text; 
using Castle.Core.Interceptor; 
using Castle.Core.Logging; 

public abstract class AbstractLoggingInterceptor : IInterceptor 
{ 
    protected readonly ILoggerFactory logFactory; 

    protected AbstractLoggingInterceptor(ILoggerFactory logFactory) 
    { 
     this.logFactory = logFactory; 
    } 

    public virtual void Intercept(IInvocation invocation) 
    { 
     ILogger logger = logFactory.Create(invocation.TargetType); 

     try 
     { 
      StringBuilder sb = null; 

      if (logger.IsDebugEnabled) 
      { 
       sb = new StringBuilder(invocation.TargetType.FullName).AppendFormat(".{0}(", invocation.Method); 

       for (int i = 0; i < invocation.Arguments.Length; i++) 
       { 
        if (i > 0) 
         sb.Append(", "); 

        sb.Append(invocation.Arguments[i]); 
       } 

       sb.Append(")"); 

       logger.Debug(sb.ToString()); 
      } 

      invocation.Proceed(); 

      if (logger.IsDebugEnabled && invocation.ReturnValue != null) 
      { 
       logger.Debug("Result of " + sb + " is: " + invocation.ReturnValue); 
      } 
     } 
     catch (Exception e) 
     { 
      logger.Error(string.Empty, e); 
      throw; 
     } 
    } 
} 
} 

journalisation complète Implemnetation

namespace Tools.CastleWindsor.Interceptors 
{ 
using Castle.Core.Logging; 

public class LoggingInterceptor : AbstractLoggingInterceptor 
{ 
    public LoggingInterceptor(ILoggerFactory logFactory) : base(logFactory) 
    { 
    } 
} 
} 

exploitation forestière Méthode

namespace Tools.CastleWindsor.Interceptors 
{ 
using Castle.Core.Interceptor; 
using Castle.Core.Logging; 
using System.Linq; 

public class MethodLoggingInterceptor : AbstractLoggingInterceptor 
{ 
    private readonly string[] methodNames; 

    public MethodLoggingInterceptor(string[] methodNames, ILoggerFactory logFactory) : base(logFactory) 
    { 
     this.methodNames = methodNames; 
    } 

    public override void Intercept(IInvocation invocation) 
    { 
     if (methodNames.Contains(invocation.Method.Name)) 
      base.Intercept(invocation); 
    } 
} 
} 

Answer 2

L'ai utilisé pour faire exactement ceci. Fonctionne très bien! Je le recommande fortement!

Answer 3

+1 sur postsharp. J'ai utilisé pour plusieurs choses (y compris certaines tentatives d'ajouter des conditions préalables et postconditions au code C#) et je ne sais pas comment je le ferais sans cela ...

Answer 4

Cela dépend dans une certaine mesure du temps que vous aurez développer et soutenir le projet pour. Bien sûr, le tissage IL est une technologie intéressante, mais que se passe-t-il si le format de métadonnées d'IL et/ou d'assemblage change à nouveau (comme il l'a fait entre 1.1 et 2.0) et que ces changements rendent l'outil incompatible avec le nouveau format.

Si vous dépendez de l'outil, cela vous empêche de mettre à jour votre technologie jusqu'à ce que l'outil la prenne en charge. En l'absence de garanties à ce sujet (ou même que le développement se poursuivra, même si cela semble probable), je serais très méfiant à l'idée de l'utiliser sur un projet à long terme.

À court terme, pas de problème.