Bringing AOP to MEF

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

using LinFu.AOP.Interfaces;
using log4net;





namespace AspectableMef
{
    public class LogMethodInvocation : IAroundInvoke
    {


        #region Data
        private static ILog logger;
        private ContextOperations contextOperationsRequired;
        #endregion

        #region Ctor
        public LogMethodInvocation(ILog logger, ContextOperations contextOperationsRequired)
        {
            if (LogMethodInvocation.logger == null)
                LogMethodInvocation.logger = logger;
            this.contextOperationsRequired = contextOperationsRequired;
        }
        #endregion

        #region IAroundInvoke Members

        public void AfterInvoke(IInvocationContext context, object returnValue)
        {
            if(contextOperationsRequired.HasFlag(ContextOperations.OnExiting))
            {
                DoLogging("Exit", context);
            }
        }

        public void BeforeInvoke(IInvocationContext context)
        {
            if (contextOperationsRequired.HasFlag(ContextOperations.OnEntered))
            {
                DoLogging("Enter", context);
            }
        }

        #endregion


        #region Private Methods

        private void DoLogging(string contextOperation, IInvocationContext context)
        {

            // check for the special attribute
            if (!context.TargetMethod.HasAttribute<LogAttribute>())
                return;

            ParameterInfo[] parameters = context.TargetMethod.GetParameters();



            StringBuilder sb = new StringBuilder();
            sb.AppendLine(contextOperation);

            sb.AppendLine(String.Format("{0}.{1}({2}) called with the following parameters ",
                context.GetType().Name,
                context.TargetMethod.Name, GetMethodArgs(parameters)));


            Type[] genArgs = context.TargetMethod.GetGenericArguments();

            sb.AppendLine("\r\nGeneric arguments : ");
            for (int i = 0; i < genArgs.Count(); i++)
            {
                sb.AppendLine(String.Format("[Name:{0}]{1}", genArgs[i].Name,
                    i < genArgs.Count()-1 ? "," : ""));
            }


            sb.AppendLine("\r\nMethod parameters : ");
            for (int i = 0; i < parameters.Count(); i++)
            {
                sb.AppendLine(String.Format("[Name:{0}, Type:{1}, Value:{2}]{3}",
                    parameters[i].Name, GetGenericsForType(parameters[i].ParameterType), context.Arguments[i],
                    i < parameters.Count()-1 ? "," : ""));
            }
            
            logger.Debug(sb.ToString());
        }



        private string GetGenericsForType(Type t)
        {
            string name = "";
            if (!t.GetType().IsGenericType)
            {
                //see if there is a ' char, which there is for
                //generic types
                int idx = t.Name.IndexOfAny(new char[] { '`', '\'' });
                if (idx >= 0)
                {
                    name = t.Name.Substring(0, idx);
                    //get the generic arguments
                    Type[] genTypes = t.GetGenericArguments();
                    //and build the list of types for the result string
                    if (genTypes.Length == 1)
                    {
                        //name+="<" + genTypes[0].Name + ">";
                        name += "<" + GetGenericsForType(genTypes[0]) + ">";
                    }
                    else
                    {
                        name += "<";
                        foreach (Type gt in genTypes)
                        {
                            name += GetGenericsForType(gt) + ", ";
                        }
                        if (name.LastIndexOf(",") > 0)
                        {
                            name = name.Substring(0,
                                name.LastIndexOf(","));
                        }
                        name += ">";
                    }
                }
                else
                {
                    name = t.Name;
                }
                return name;
            }
            else
            {
                return t.Name;
            }
        }



        private string GetMethodArgs(ParameterInfo[] parameters)
        {
            StringBuilder sb = new StringBuilder();

            for (int i = 0; i < parameters.Count(); i++)
            {
                sb.AppendFormat("{0} {1}{2}", GetGenericsForType(parameters[i].ParameterType), parameters[i].Name, 
                    i < parameters.Count()-1 ? "," : "");
            }
            return sb.ToString();
        }

        #endregion
    }

}