Question

I am considering using Postsharp framework to ease the burden of application method logging. It basically allows me to adorn methods with logging attribute and at compile time injects the logging code needed into the il. I like this solution as it keeps the noise out of the deign time code environment. Any thoughts, experiences or better alternatives?

Answer 1

I apply logging with AOP using Castle Windsor DynamicProxies. I was already using Castle for it’s IoC container, so using it for AOP was the path of least resistence for me. If you want more info let me know, I’m in the process of tidying the code up for releasing it as a blog post

Edit

Ok, here’s the basic Intercepter code, faily basic but it does everything I need. There are two intercepters, one logs everyhing and the other allows you to define method names to allow for more fine grained logging. This solution is faily dependant on Castle Windsor

Abstract Base class

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

Full Logging Implemnetation

namespace Tools.CastleWindsor.Interceptors { using Castle.Core.Logging;  public class LoggingInterceptor : AbstractLoggingInterceptor {     public LoggingInterceptor(ILoggerFactory logFactory) : base(logFactory)     {     } } } 

Method logging

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