PROPRIÉTÉS D'EXTENSION AVEC C# 3.0

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using PostSharp.Laos;
using System.Reflection;
using PostSharp.Extensibility;
using System.Text.RegularExpressions;

namespace ExtensionProperties
{
    /// <summary>
    /// Classe de base pour intercepter les méthodes d'extension "propriétés"
    /// </summary>
    [Serializable]
    public abstract class BasePropertyInterceptor : OnMethodBoundaryAspect
    {
        protected static PropertyContainer PropertyValues = PropertyContainer.GetInstance();

        public override void OnEntry(MethodExecutionEventArgs e)
        {
            OwnerType = e.Method.GetParameters()[0].ParameterType;
            Owner = e.GetArguments()[0];
            if (e.GetArguments().Length > 1)
                Value = e.GetArguments()[1];
        }

        public override void CompileTimeInitialize(MethodBase method)
        {
            MethodName = method.Name;
        }

        /// <summary>
        /// Type de l'objet portant la méthode-"propriété".
        /// </summary>
        public Type OwnerType { get; set; }
        
        /// <summary>
        /// Instance de l'objet portant la méthode-"propriété".
        /// </summary>        
        public object Owner { get; set; }

        /// <summary>
        /// Nom de la méthode-"propriété".
        /// </summary>
        public virtual string MethodName { get; set; } 
        
        /// <summary>
        /// Valeur de la propriété.
        /// </summary>       
        public object Value { get; set; }

        [Serializable]
        protected class PropertyContainer : Dictionary<Type, Dictionary<object, Dictionary<string, object>>>
        {
            // Design pattern singleton
            private static PropertyContainer instance = null;

            private PropertyContainer() { }

            public static PropertyContainer GetInstance()
            {
                if (instance == null)
                    instance = new PropertyContainer();
                return instance;
            }

            // Redéfinition d'indexeurs
            public object this[Type objtype, object obj, string propertyName]
            {
                get
                {
                    try { return base[objtype][obj][propertyName]; }
                    catch { return null; }
                }
            }

            public Dictionary<string, object> this[Type objtype, object obj]
            {
                get
                {
                    try { return base[objtype][obj]; }
                    catch { return null; }
                }
            }
        }    
    }


    /// <summary>
    /// Attribut à associer à la classe contenant les méthodes d'extension. Il intercepte les méthodes d'extension "Get*"/"Set*" et renvoit/stock les valeurs.
    /// </summary>
    [Serializable]
    public class InterceptProperties : BasePropertyInterceptor
    {
        private Get _Getter;
        private Set _Setter;

        public override void CompileTimeInitialize(MethodBase method)
        {
            base.CompileTimeInitialize(method);
            if (method.Name.StartsWith("Get"))
            {
                CheckAccessorAttributes(method);

                // la méthode "Get" doit être sans paramètre.
                if (method.GetParameters().Length != 1)
                    throw new Exception(string.Format("Une méthode dont le nom commence par \"Get\" a été trouvée, mais elle possède un ou plusieurs paramètres sans modificateur \"this\".", method.Name));
                var instance = method.GetParameters()[0];

                // on cherche une methode portée par la même classe, de même nom et possédant un attribut "Set".
                var presumedSetters = method.DeclaringType.GetMethods().Where(m => m.Name.StartsWith("Set") && m.GetParameters().Length > 0 && m.GetParameters()[0].ParameterType.ToString() == instance.ParameterType.ToString());
                if (presumedSetters.Count() == 0)
                    throw new Exception(string.Format("Imposssible de trouver une méthode \"{0}\" de {1} dont le nom commence par \"Set\".", method.Name, instance.ParameterType));
            }
            if (method.Name.StartsWith("Set"))
            {
                CheckAccessorAttributes(method);

                // on vérifie que la méthode ne possède qu'un seul paramètre.
                ParameterInfo param;
                if (method.GetParameters().Length != 2)
                    throw new Exception(string.Format("La méthode \"{0}\" définie comme accesseur \"set\" doit posséder un unique paramètre sans modificateur \"this\".", method.Name));
                param = method.GetParameters()[1];
                var instance = method.GetParameters()[0];

                // on cherche une methode portée par la même classe, de même nom et possédant un attribut "Get".
                var presumedGetters = method.DeclaringType.GetMethods().Where(m => m.Name.StartsWith("Get") && m.GetParameters().Length > 0 && m.GetParameters()[0].ParameterType.ToString() == instance.ParameterType.ToString());
                if (presumedGetters.Count() == 0)
                    throw new Exception(string.Format("Imposssible de trouver une méthode \"{0}\" de {1} dont le nom commence par \"Get\".", method.Name, instance.ParameterType));

                // la méthode "Get" doit avoir une valeur de retour du même type que le paramètre de la méthode "Set".
                presumedGetters = presumedGetters.Where(m => m.ReturnType == param.ParameterType);
                if (presumedGetters.Count() == 0)
                    throw new Exception(string.Format("Une méthode dont le nom commence par \"Get\" a été trouvée, mais le type de son paramètre de retour ne correspond pas à celui du paramètre de la méthode \"Set\".", method.Name));
            }
        }

        protected void CheckAccessorAttributes(MethodBase method)
        {
            var setAttr = method.GetCustomAttributes(typeof(Set), false);
            var getAttr = method.GetCustomAttributes(typeof(Get), false);
            if (setAttr != null && setAttr.Length != 0)
                throw new Exception(string.Format("La méthode \"{0}\" ne doit pas avoir d'attribut \"Set\" associé",method.Name));
            if (getAttr != null && getAttr.Length != 0)
                throw new Exception(string.Format("La méthode \"{0}\" ne doit pas avoir d'attribut \"Get\" associé",method.Name));
        }

        public override void OnEntry(MethodExecutionEventArgs e)
        {
            base.OnEntry(e);
            if (e.Method.Name.StartsWith("Set"))
                Setter.OnEntry(e);
        }

        public override void OnExit(MethodExecutionEventArgs e)
        {
            if (e.Method.Name.StartsWith("Get"))
                Getter.OnExit(e);
        }


        public override string MethodName
        {
            get { return base.MethodName.Substring(3); }
        }

        // Il faut propager les infos OwnerType, Owner, MethodName et Value vers nos objets Getter et Setter car ceux-ci n'interceptent pas directement les méthodes.
        private Get Getter
        {
            get
            {
                if (_Getter == null || (_Getter!=null && _Getter.Owner!=this.Owner))
                    _Getter = new Get
                    {
                        OwnerType = this.OwnerType,
                        Owner = this.Owner,
                        MethodName = this.MethodName,
                        Value = this.Value
                    };
                return _Getter;
            }
        }

        private Set Setter
        {
            get
            {
                if (_Getter == null || (_Getter!=null && _Getter.Owner!=this.Owner))
                    _Setter = new Set
                    {
                        OwnerType = this.OwnerType,
                        Owner = this.Owner,
                        MethodName = this.MethodName,
                        Value = this.Value
                    };
                return _Setter;
            }
        }
    }

    /// <summary>
    /// Attribut à associer à une méthode d'extension pour que celle-ci remplace un accesseur "get" d'une propriété.
    /// </summary>
    [Serializable]
    [MulticastAttributeUsage(MulticastTargets.Method, PersistMetaData = true)]
    public class Get : BasePropertyInterceptor
    {
        public override void CompileTimeInitialize(MethodBase method)
        {
            base.CompileTimeInitialize(method);
            // la méthode "Get" doit être sans paramètre.
            if (method.GetParameters().Length != 1)
                throw new Exception(string.Format("Une méthode \"{0}\" portant un attribut \"Get\" a été trouvée, mais elle possède un ou plusieurs paramètres sans modificateur \"this\".", method.Name));
            var instance = method.GetParameters()[0];

            // on cherche une methode portée par la même classe, de même nom et possédant un attribut "Set".
            var presumedSetters = method.DeclaringType.GetMethods().Where(m =>
            {
                if (m.Name == method.Name && m.GetParameters().Length > 0 && m.GetParameters()[0].ParameterType.ToString() == instance.ParameterType.ToString())
                {
                    var attrs = m.GetCustomAttributes(typeof(Set), false);
                    if (attrs != null && attrs.Length != 0)
                        return true;
                }
                return false;
            });
            if (presumedSetters.Count() == 0)
                throw new Exception(string.Format("Imposssible de trouver une méthode \"{0}\" de {1} portant un attribut \"Set\".", method.Name, instance.ParameterType));
        }

        public override void OnExit(MethodExecutionEventArgs e)
        {
            e.ReturnValue = PropertyValues[OwnerType, Owner, MethodName];
        }
    }

    /// <summary>
    /// Attribut à associer à une méthode d'extension pour que celle-ci remplace un accesseur "set" d'une propriété.
    /// </summary>
    [Serializable]
    [MulticastAttributeUsage(MulticastTargets.Method, PersistMetaData=true)]
    public class Set : BasePropertyInterceptor
    {
        public override void CompileTimeInitialize(MethodBase method)
        {
            base.CompileTimeInitialize(method);
            // on vérifie que la méthode ne possède qu'un seul paramètre.
            if (method.GetParameters().Length != 2)
                throw new Exception(string.Format("La méthode \"{0}\" définie comme accesseur \"set\" doit posséder un unique paramètre sans modificateur \"this\".", method.Name));
            var param = method.GetParameters()[1];
            var instance = method.GetParameters()[0];

            // on cherche une methode portée par la même classe, de même nom et possédant un attribut "Get".
            var presumedGetters = method.DeclaringType.GetMethods().Where(m => 
                {
                    if (m.Name == method.Name && m.GetParameters().Length > 0 && m.GetParameters()[0].ParameterType.ToString() == instance.ParameterType.ToString())
                    {
                        var attrs = m.GetCustomAttributes(typeof(Get), false);
                        if (attrs != null && attrs.Length != 0)
                            return true;
                    }
                    return false;
                });
            if(presumedGetters.Count()==0)
                throw new Exception(string.Format("Imposssible de trouver une méthode \"{0}\" de {1} portant un attribut \"Get\".", method.Name, instance.ParameterType));

            // la méthode "Get" doit avoir une valeur de retour du même type que le paramètre de la méthode "Set".
            presumedGetters = presumedGetters.Where(m => m.ReturnType == param.ParameterType);
            if (presumedGetters.Count() == 0)
                throw new Exception(string.Format("Une méthode \"{0}\" portant un attribut \"Get\" a été trouvée, mais le type de son paramètre de retour ne correspond pas à celui du paramètre de la méthode \"Set\".", method.Name));
        }

        public override void OnEntry(MethodExecutionEventArgs e)
        {
            base.OnEntry(e);
            if (Value == null)
                return;
            if (!PropertyValues.ContainsKey(OwnerType))
                PropertyValues.Add(OwnerType, new Dictionary<object, Dictionary<string, object>>());
            if (!PropertyValues[OwnerType].ContainsKey(Owner))
                PropertyValues[OwnerType].Add(Owner, new Dictionary<string, object>());
            if (!PropertyValues[OwnerType, Owner].ContainsKey(MethodName))
                PropertyValues[OwnerType, Owner].Add(MethodName, Value);
        }
    }
}