PostSharp - il weaving - thoughts

Question

Estoy considerando utilizar el marco de trabajo de Postsharp para aliviar la carga del registro del método de aplicación. Básicamente, me permite adornar métodos con el atributo de registro y en tiempo de compilación inyecta el código de registro necesario en el il. Me gusta esta solución ya que mantiene el ruido alejado del entorno del código de tiempo deignar. ¿Alguna idea, experiencia o mejores alternativas?

Answer 1

Aplico el registro con AOP usando Castle Windsor DynamicProxies. Ya estaba usando Castle para su contenedor IoC, así que usarlo para AOP fue el camino de menor resistencia para mí. Si desea más información, hágamelo saber, estoy en el proceso de poner en orden el código para liberarlo como una entrada en el blog

Editar

Ok, aquí está el código intercepter básica, faily básico, pero lo hace todo Necesito. Hay dos interceptadores, uno registra todos y el otro le permite definir nombres de métodos para permitir un registro de grano más fino. Esta solución depende faily en el castillo de Windsor clase

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

registro completo Implemnetation

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

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

método de registro

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

Lo he usado para hacer exactamente esto. ¡Funciona genial! ¡Lo recomiendo encarecidamente!

Answer 3

+1 en postsharp. He estado usando varias cosas (incluidos algunos intentos de agregar condiciones previas y posteriores al código C#) y no sé cómo lo haría sin él ...

Answer 4

Depende en cierta medida del tiempo que tenga. desarrollar y apoyar el proyecto para. Claro, IL weaving es una buena tecnología, pero ¿qué sucede si el formato de metadatos IL y/o conjunto cambia de nuevo (como lo hizo entre 1.1 y 2.0) y esos cambios hacen que la herramienta sea incompatible con el nuevo formato.

Si depende de la herramienta, le impide actualizar su tecnología hasta que la herramienta la admita. Sin garantías sobre esto (o incluso que el desarrollo continuará, aunque parece probable) entonces sería muy cauteloso sobre su uso en un proyecto a largo plazo.

A corto plazo, no hay problema.