Dynamic Decorator and Castle DynamicProxy Comparison

//******************************************************************
// Proxy
//******************************************************************

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.Remoting.Proxies;
using System.Runtime.Remoting.Messaging;
using System.Reflection;
using System.Diagnostics;
using System.ComponentModel;

namespace MefWithAspects.Aspects
{
    public class AspectProxy : RealProxy, IDisposable
    {
        public object RealInstance { get; private set; }

        public AspectProxy(object subject)
            : base(subject.GetType())
        {

            this.RealInstance = subject;
       

            //We have to attach our object to the proxy.  
            //This isn't an automagic thing, probably because it isn't always relevant.
            AttachServer((MarshalByRefObject)subject);
        }

      

 

        public void Dispose()
        {
            //For proper cleanup, let's detach our server. 
            DetachServer();
        }


        public override IMessage Invoke(IMessage msg)
        {
            ///the MethodCallMessageWrapper provides read/write access to the method call arguments. 
            MethodCallMessageWrapper mc = new MethodCallMessageWrapper((IMethodCallMessage)msg);
            ///This is the reflected method base of the called method. 
            MethodInfo mi = (MethodInfo)mc.MethodBase;
            ///This is the object we are proxying. 
            MarshalByRefObject owner = GetUnwrappedServer();
            ///Some basic initializations for later use 
            IMessage retval = null;
            object outVal = null;

            //check for custom attributes
            object[] attribs = mi.GetCustomAttributes(typeof(IContextBound), true);
            IEnumerable<IContextBound> enteredAttribs = (from x in attribs
                                                         where
                                                             ((IContextBound)x).ContextOperationsRequired.HasFlag(ContextOperations.OnEntered)
                                                         select (IContextBound)x);
            IEnumerable<IContextBound> exitingAttribs = (from x in attribs
                                                         where
                                                             ((IContextBound)x).ContextOperationsRequired.HasFlag(ContextOperations.OnExiting)
                                                         select (IContextBound)x);

            bool isMethodCallAllowed = true;


            //call the OnEntered based ones
            foreach (IContextBound contextBoundAttrib in enteredAttribs)
            {
                isMethodCallAllowed &= contextBoundAttrib.OnContextEntered(owner, mi, mc.Args);
            }

            //call the method
            if (isMethodCallAllowed)
            {
                outVal = mi.Invoke(owner, mc.Args);
                retval = new ReturnMessage(outVal, mc.Args, mc.Args.Length, mc.LogicalCallContext, mc);
            }
            else
            {
                retval = new ReturnMessage(outVal, mc.Args, mc.Args.Length, mc.LogicalCallContext, mc);
            }

            //call the OnExiting based ones
            foreach (IContextBound contextBoundAttrib in exitingAttribs)
            {
                contextBoundAttrib.OnContextExiting(owner, mi, mc.Args);
            }
            return retval;

        }


        public static Object Factory(object obj)
        {
            return new AspectProxy(obj).GetTransparentProxy();
        }
    }  
}








//******************************************************************
// Helper interface
//******************************************************************
using System;
using System.Reflection;

namespace MefWithAspects.Aspects
{
    [Flags]
    public enum ContextOperations
    {
        OnEntered = 0,
        OnExiting = 1
    }



    public interface IContextBound
    {
        /// <summary>
        /// This method should be used to carry out any on entered context logic that occurs when an apsect enabled
        /// objects method is entered. Since the method call has not occurred yet, you are able to return true/false
        /// depending on whether you wish the context method call to be able to run or not
        /// </summary>
        /// <param name="content">The object the aspect is applied to</param>
        /// <param name="method">The method being entered on the context object</param>
        /// <param name="args">The method arguments</param>
        /// <returns>Return true/false depending on whether you wish the context method call to run or not</returns>
        bool OnContextEntered(object content, MethodInfo method, Object[] args);

        /// <summary>
        /// This method should be used to carry out any on exiting context logic that occurs when an apsect enabled
        /// objects method is just about to exit. Since the method has already run there may not be anything to do 
        /// in this method
        /// </summary>
        /// <param name="content">The object the aspect is applied to</param>
        /// <param name="method">The method being entered on the context object</param>
        /// <param name="args">The method arguments</param>
        void OnContextExiting(object content, MethodInfo method, Object[] args);

        /// <summary>
        /// Specifies what <c>ContextOperations</c> the implmenting class supports
        /// </summary>
        ContextOperations ContextOperationsRequired { get; }
    }

}





//******************************************************************
// Logging apsect
//******************************************************************

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Reflection;

using System.ComponentModel.Composition;
using log4net;

namespace MefWithAspects.Aspects
{
    [AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, AllowMultiple = false)]
    public class LoggerContextAttribute : Attribute, IContextBound
    {
        #region Data
        private static ILog logger;
        private ContextOperations contextOperationsRequired;
        #endregion

        #region Ctor
        public LoggerContextAttribute(ContextOperations contextOperationsRequired)
        {
            this.contextOperationsRequired = contextOperationsRequired;
        }
        #endregion

        #region Public Methods
        public static void SetLogger(ILog newLogger)
        {
            logger = newLogger;
        }
        #endregion

        #region IContextBound Members

        public bool OnContextEntered(object contextObject, MethodInfo method, Object[] args)
        {
            DoLogging("Enter", contextObject, method, args);
            return true; //Simply allows context to continue
        }

        public void OnContextExiting(object contextObject, MethodInfo method, Object[] args)
        {
            DoLogging("Exiting", contextObject, method, args);
        }

        public ContextOperations ContextOperationsRequired
        {
            get { return contextOperationsRequired; }
        }

        #endregion

        #region Private Methods
        private void DoLogging(string contextOperation, object contextObject, MethodInfo method, Object[] args)
        {
            StringBuilder sb = new StringBuilder();
            sb.AppendLine(String.Format("{0} {1} : {2}", DateTime.Now.ToShortDateString(), DateTime.Now.ToShortTimeString(), contextOperation));
            sb.AppendLine(String.Format("{0} {1} : {2}.{3}(..) called with the following parameters",
                DateTime.Now.ToShortDateString(), DateTime.Now.ToShortTimeString(), contextObject.GetType().Name, method.Name));
            int i = 0;
            foreach (ParameterInfo parameter in method.GetParameters())
            {
                sb.AppendLine(String.Format("{0} {1} : Name : {2}, Type: {3}, Value: {4}",
                    DateTime.Now.ToShortDateString(), DateTime.Now.ToShortTimeString(), parameter.Name, parameter.ParameterType, args[i]));
                i++;
            }
            logger.Debug(sb.ToString());
        }
        #endregion
    }
}



//******************************************************************
//Here is how I would create a aspect enabled class
//******************************************************************
AspectProxy.Factory(new MainWindowViewModel());






//******************************************************************
// Aspected class
//******************************************************************
public class MainWindowViewModel : MarshalByRefObject
    {
        public virtual int UniqueId { get; private set; }


        [LoggerContextAttribute(ContextOperations.OnEntered | ContextOperations.OnExiting)]
        public virtual int Age { get; set; }


        [LoggerContextAttribute(ContextOperations.OnEntered | ContextOperations.OnExiting)]
        public virtual void SetSomething<T>(T value, int ageValue)
        {
            T x = value;
            this.Age = ageValue;
            UniqueId = ++UniqueId;
        }




        public MainWindowViewModel()
        {
            Age = 1;
            UniqueId = ++UniqueId;
        }
    }