public interface IInterceptor
{
    void Intercept(IInvocation invocation);
}

public class LoggingInterceptor : IInterceptor
{
    private ILog mLog = LogManager.GetLogger("MyLogger");
    public void Intercept(IInvocation invocation)
    {
        mLog.DebugFormat("Entering {0}, with parameters {1}",
                         invocation.Method,
                         GetParameters(invocation));
        try
        {
            invocation.Proceed();
            mLog.DebugFormat("Exiting {0} with return value: {1}",
                              invocation.Method,
                              invocation.ReturnValue);
        }
        catch (Exception ex)
        {
            mLog.Error("An error occured on " + invocation.Method, ex);
            throw;
        }
    }
    private static string GetParameters(IInvocation call)
    {
        return string.Join
            (",",
             call.Method.GetParameters().Select((x, i) =>
                                                new {x.Name, Index = i}).
                 Select(x => x.Name + ":" + call.Arguments[x.Index]));
    }
}

Bank myBank = new Bank();
ProxyGenerator generator = new ProxyGenerator();
IBank intercepted = generator.CreateInterfaceProxyWithTargetInterface<IBank>(myBank, new LoggingInterceptor());
intercepted.GetAvailableBudget("My Identity"); // Logs!

[AttributeUsage(AttributeTargets.Class)]
public class LogAttribute : ContextAttribute
{
    #region Constructor
    public LogAttribute()
        : base("Log")
    {
    }
    #endregion
    #region ContextAttribute Overrides
    public override void Freeze(Context newContext)
    {
    }
    public override void GetPropertiesForNewContext(System.Runtime.Remoting.Activation.IConstructionCallMessage ctorMsg)
    {
        ctorMsg.ContextProperties.Add(new LogProperty());
    }
    public override bool IsContextOK(Context ctx, System.Runtime.Remoting.Activation.IConstructionCallMessage ctorMsg)
    {
        LogProperty property =
            ctx.GetProperty("Log") as LogProperty;
        if (property == null)
        {
            return false;
        }
        return true;
    }
    public override bool IsNewContextOK(Context newCtx)
    {
        LogProperty property =
            newCtx.GetProperty("Log") as LogProperty;
        if (property == null)
        {
            return false;
        }
        return true;
    }
    #endregion
}
public class LogProperty : IContextProperty, IContributeObjectSink
{
    #region IContextProperty Members
    public string Name
    {
        get
        {
            return "Log";
        }
    }
    
    public bool IsNewContextOK(Context newCtx)
    {
        LogProperty property =
            newCtx.GetProperty("Log") as LogProperty;
        if (property == null)
        {
            return false;
        }
        return true;
    }
    public void Freeze(Context newContext)
    {
    }
    #endregion
    #region IContributeObjectSink Members
    public IMessageSink GetObjectSink(MarshalByRefObject obj, IMessageSink nextSink)
    {
        return new LogSink(nextSink);
    }
    #endregion
}
public class LogSink : IMessageSink
{
    #region Data Members
    private IMessageSink mNextSink;
    private ILog mLog = LogManager.GetLogger("MyLogger");
    #endregion
    #region Constructor
    public LogSink(IMessageSink nextSink)
    {
        this.mNextSink = nextSink;
    }
    #endregion
    #region IMessageSink Members
    public IMessage SyncProcessMessage(IMessage msg)
    {
        IMethodCallMessage call = msg as IMethodCallMessage;
        mLog.DebugFormat("Entering {0}, with parameters {1}",
                         call.MethodBase.Name,
                         GetParameters(call));
        IMethodReturnMessage result =
            mNextSink.SyncProcessMessage(msg) as IMethodReturnMessage;
        if (result.Exception != null)
        {
            mLog.Error("An error occured on " + call.MethodBase.Name,
                       result.Exception);
        }
        else
        {
            mLog.DebugFormat("Exiting {0} with return value: {1}",
                             result.MethodBase,
                             result.ReturnValue);
        }
        return result;
    }
    public IMessageSink NextSink
    {
        get
        {
            return this.mNextSink;
        }
    }
    public IMessageCtrl AsyncProcessMessage(IMessage msg, IMessageSink  replySink)
    {
        IMessageCtrl rtnMsgCtrl = mNextSink.AsyncProcessMessage(msg, replySink);
        return rtnMsgCtrl;
    }
    private string GetParameters(IMethodCallMessage call)
    {
        return string.Join
            (",",
             call.MethodBase.GetParameters().Select((x, i) =>
                                                new { x.Name, Index = i }).
                 Select(x => x.Name + ":" + call.Args[x.Index]));
    }
    #endregion
}

[Log]
public class Bank : ContextBoundObject, IBank
{
    // ...
}

Bank myBank = new Bank();
myBank.GetAvailableBudget("My Identity"); // Logs!

/// <summary>
/// Logs exceptions thrown out of the method call
/// </summary>
[AttributeUsage(AttributeTargets.Method)]
public class LogExceptionsAttribute : AspectAttribute
{
    private ILogger mLog;
    private LogLevel mLevel = LogLevel.Error;
    #region AspectAttribute Members
    public override void PostProcess(ProcessingContext context)
    {
        if (context.ReturnMessage.Exception != null)
        {
            // Initialize the logger first time the method is called.
            if (mLog == null)
            {
                mLog = Infrastructure.GetLayer<ILoggingLayer>().
                                      GetLogger(context.ReturnMessage.MethodBase.DeclaringType.ToString());
            }
            mLog.Log(mLevel, context.ReturnMessage.Exception);
        }
    }
    #endregion
    #region Properties
    /// <summary>
    /// Gets or sets the log level of the exceptions thrown out of the method
    /// </summary>
    public LogLevel Level
    {
        get
        {
            return mLevel;
        }
        set
        {
            mLevel = value;
        }
    }
    #endregion
}

[Log]
[Validate]
public void Deposit([NotNull]string id, [IsPositive]int amount)
{
    // ...
}

public interface IInterceptor
{
    void Intercept(MethodCallInfo call);
}

public class LoggingInterceptor : IInterceptor
{
    public void Intercept(MethodCallInfo call)
    {
        Console.WriteLine("Entering {0}, with parameters {1}",
                         call.Method,
                         GetParameters(call));
        try
        {
            call.Proceed();
            Console.WriteLine("Exiting {0} with return value: {1}",
                             call.Method,
                             call.ReturnValue);
        }
        catch (Exception ex)
        {
            Console.WriteLine("An error occured on " + call.Method, ex);
            throw;
        }
    }
    private static string GetParameters(MethodCallInfo call)
    {
        return string.Join
            (",",
             call.Method.GetParameters().Select(x => x.Name + ":" + call.Arguments[x.Position]));
    }
}

public int MyMethod(int id, string name)
{
    // MyMethod Content
}

public int MyMethod(int id, string name)
{
    if (id < 0)
    {
        throw new ArgumentException("Argument must be positive", "id");
    }
    if (name == null)
    {
        throw new ArgumentNullException("name");
    }
    // MyMethod Content
}

[AttributeUsage(AttributeTargets.Parameter, Inherited = false, AllowMultiple = false)]
public abstract class ValidationAttribute : Attribute
{
    public abstract bool IsValid(object obj);
}

public class NotNullAttribute : ValidationAttribute
{
    public override bool IsValid(object obj)
    {
        return (obj != null);
    }
}
public class IsPositiveAttribute : ValidationAttribute
{
    public override bool IsValid(object obj)
    {
        int? value = obj as int?;
        return (value >= 0);
    }
}

private void Route(MethodCallInfo call)
{
    var parameters =
        call.Method.GetParameters().
        Select((x, i) => new {Parameter = x, Index = i})
        .Where(x => x.Parameter.GetCustomAttributes(true)
                        .OfType<ValidationAttribute>().Any());
    foreach (var parameter in parameters)
    {
        ValidationAttribute attribute =
            parameter.Parameter.GetCustomAttributes(true)
                .OfType<ValidationAttribute>().First();
        if (!attribute.IsValid(call.Arguments[parameter.Index]))
        {
            throw new ArgumentException("Argument wasn't valid",
                                        parameter.Parameter.Name);
        }
    }
    call.Proceed();
}

public int MyMethod([IsPositive]int id, [NotNull]string name)
{
    // MyMethod Content
}

public int MyMethod(int id, string name)
{
    Stopwatch sw = new Stopwatch();
    sw.Start();
    // My Method content
    sw.Stop();
    mLog.DebugFormat("My method took {0} milli-seconds to run",
                     sw.ElapsedMilliseconds);
    return result;
}

private void Route(MethodCallInfo call)
{
    Stopwatch sw = new Stopwatch();
    sw.Start();
    call.Proceed();
    sw.Stop();
    mLog.DebugFormat("My method took {0} milli-seconds to run",
                     sw.ElapsedMilliseconds);
}

public int MyMethod(int id, string name)
{
    mLog.DebugFormat("Entering MyMethod, with parameters id:{0}, name:{1}",
                     id, name);
    try
    {
        int result;
        // My Method content
        mLog.DebugFormat("Exiting MyMethod with return value: {0}", result);
        return result;
    }
    catch (Exception ex)
    {
        mLog.Error("An error occured on MyMethod", ex);
        throw;
    }
}

public void Route(MethodCallInfo call)
{
    call.Proceed();
}

private void Route(MethodCallInfo call)
{
    mLog.DebugFormat("Entering {0}, with parameters {1}",
                     call.Method,
                     GetParameters(call));
    try
    {
        call.Proceed();
        mLog.DebugFormat("Exiting {0} with return value: {1}",
                         call.Method,
                         call.ReturnValue);
    }
    catch (Exception ex)
    {
        mLog.Error("An error occured on " + call.Method, ex);
        throw;
    }
}

private static string GetParameters(MethodCallInfo call)
{
    return string.Join
        (",",
         call.Method.GetParameters().Select(x => x.Name + ":" + call.Arguments[x.Position]));
}

public class BankInterception : IBank
{
    private IBank mSource;
    public BankInterception(IBank source)
    {
        mSource = source;
    }
    public void Deposit(string id, int amount)
    {
        WriteMethodCall(new MethodCallInfo("Deposit")
                   {
                       {"id", id},
                       {"amount", amount}
                   });
        mSource.Deposit(id, amount);
        WriteMethodReturn(new MethodCallInfo("Deposit"));
    }
    public void Withdraw(string id, int amount)
    {
        WriteMethodCall(new MethodCallInfo("Withdraw")
                   {
                       {"id", id},
                       {"amount", amount}
                   });
        mSource.Withdraw(id, amount);
        WriteMethodReturn(new MethodCallInfo("Withdraw"));
    }
    public int GetAvailableBudget(string id)
    {
        WriteMethodCall(new MethodCallInfo("GetAvailableBudget")
                   {
                       {"id", id},
                   });
        int result = mSource.GetAvailableBudget(id);
        WriteMethodReturn(new MethodCallInfo("GetAvailableBudget")
                              {
                                  ReturnValue = result
                              });
        return result;
    }
    private static void WriteMethodCall(MethodCallInfo methodCallInfo)
    {
        Console.WriteLine("Called {0} with arguments:");
        foreach (KeyValuePair<string, object> argument in methodCallInfo)
        {
            Console.WriteLine("\t{0} : {1}",
                              argument.Key,
                              argument.Value);
        }
    }
    private static void WriteMethodReturn(MethodCallInfo methodCallInfo)
    {
        Console.WriteLine("Returned from {0} with value {1}.",
                          methodCallInfo.Name,
                          methodCallInfo.ReturnValue);
    }
}

Bank myBank = new Bank();
IBank intercepted = new BankInterception(myBank);
intercepted.Deposit("6a91e9f9813a479db7c4bf549bb91c4d", 300);
// Prints to console the parameters

public int GetAvailableBudget(string id)
{
    MethodCallInfo methodCallInfo =
        new MethodCallInfo
            ("GetAvailableBudget",
             mSource,
             message => mSource.GetAvailableBudget((string) message.Arguments[0]))
            {
                {"id", id},
            };
    Route(methodCallInfo);
    return (int)methodCallInfo.ReturnValue;
}
private void Route(MethodCallInfo methodCallInfo)
{
    WriteMethodCall(methodCallInfo);
    methodCallInfo.Proceed();
    WriteMethodReturn(methodCallInfo);
}

public int GetAvailableBudget(string id)
{
    MethodCallInfo callInfo =
        new MethodCallInfo("GetAvailableBudget",
                           message => InnerGetAvailableBudget
                               ((string) message.Arguments[0]))
            {
                {"id", id},
            };
    Route(callInfo);
    return (int)callInfo.ReturnValue;
}
private int InnerGetAvailableBudget(string id)
{
    // Implementation
}
private void Route(MethodCallInfo methodCallInfo)
{
    Console.WriteLine("Called {0} with arguments:");
    foreach (KeyValuePair<string, object> argument in methodCallInfo)
    {
        Console.WriteLine("\t{0} : {1}",
                          argument.Key,
                          argument.Value);
    }
    methodCallInfo.Proceed();
    Console.WriteLine("Returned from {0} with value {1}.",
                      methodCallInfo.Name,
                      methodCallInfo.ReturnValue);
}

public class Bank : IBank
{
    public void Deposit(string id, int amount)
    {
        // Implementation of Deposit
    }
    public void Withdraw(string id, int amount)
    {
        // Implementation of Withdraw
    }
    public int GetAvailableBudget(string id)
    {
        // Implementation of GetAvailableBudget
    }
}

public class Bank : IBank
{
    public void Deposit(string id, int amount)
    {
        WriteCall(new MethodCallInfo("Deposit")
                       {
                           {"id", id},
                           {"amount", amount}
                       });
        // Implementation of Deposit
        WriteCallReturn(new MethodReturnInfo("Deposit"));
    }
    public void Withdraw(string id, int amount)
    {
        WriteCall(new MethodCallInfo("Withdraw")
                       {
                           {"id", id},
                           {"amount", amount}
                       });
        // Implementation of Withdraw
        WriteCallReturn(new MethodReturnInfo("Withdraw"));
    }
    public int GetAvailableBudget(string id)
    {
        WriteCall(new MethodCallInfo("GetAvailableBudget")
                       {
                           {"id", id},
                       });
        // Implementation of GetAvailableBudget
        int result;
        // End implementation of GetAvailableBudget
        WriteCallReturn(new MethodReturnInfo("GetAvailableBudget") { ReturnValue = result });
    }
    private void WriteCall(MethodCallInfo methodCallInfo)
    {
        Console.WriteLine("Called {0} with arguments:");
        foreach (KeyValuePair<string, object> argument in methodCallInfo)
        {
            Console.WriteLine("\t{0} : {1}",
                              argument.Key,
                              argument.Value);
        }
    }
    private void WriteCallReturn(MethodReturnInfo methodReturnInfo)
    {
        Console.WriteLine("Returned from {0} with value {1}.",
                          methodReturnInfo.Name,
                          methodReturnInfo.ReturnValue);
    }
}