改进篇《不使用反射进行C#属性的运行时动态访问》

 在工作中看到

using System;
using System.Collections.Generic;

namespace XXX.Common
{
    public interface INamedMemberAccessor
    {
        object GetValue(object instance);
        void SetValue(object instance, object newValue);
    }

    public interface IMemberAccessor
    {
        object GetValue(object instance, string memberName);
        void SetValue(object instance, string memberName, object newValue);
    }

    internal class PropertyAccessor<T, P> : INamedMemberAccessor
    {
        private Func<T, P> GetValueDelegate;
        private Action<T, P> SetValueDelegate;

        public PropertyAccessor(Type type, string propertyName)
        {
            var propertyInfo = type.GetProperty(propertyName);
            if (null != propertyInfo)
            {
                var getMethodInfo = propertyInfo.GetGetMethod();
                if (null != getMethodInfo)
                { GetValueDelegate = (Func<T, P>)Delegate.CreateDelegate(typeof(Func<T, P>), getMethodInfo); }

                var setMethodInfo = propertyInfo.GetSetMethod();
                if (null != setMethodInfo)
                { SetValueDelegate = (Action<T, P>)Delegate.CreateDelegate(typeof(Action<T, P>), setMethodInfo); }
            }
        }

        public object GetValue(object instance)
        {
            Guard.ArgumentNotNull(GetValueDelegate, "The Property isn't have GetMethod");
            return GetValueDelegate((T)instance);
        }

        public void SetValue(object instance, object newValue)
        {
            Guard.ArgumentNotNull(SetValueDelegate, "The Property isn't have SetMethod");
            SetValueDelegate((T)instance, (P)newValue);
        }
    }

    public class MemberAccessor : IMemberAccessor
    {
        #region Singleton
        private MemberAccessor() { }
        public static MemberAccessor Instance
        {
            get { return Nested.instance; }
        }
        private class Nested
        {
            static Nested() { }
            internal static readonly MemberAccessor instance = new MemberAccessor();
        }
        #endregion

        private static Dictionary<string, INamedMemberAccessor> accessorCache = new Dictionary<string, INamedMemberAccessor>();

        public object GetValue(object instance, string memberName)
        {
            return FindAccessor(instance, memberName).GetValue(instance);
        }

        public void SetValue(object instance, string memberName, object newValue)
        {
            FindAccessor(instance, memberName).SetValue(instance, newValue);
        }

        private INamedMemberAccessor FindAccessor(object instance, string memberName)
        {
            Type type = instance.GetType();
            string key = type.FullName + memberName;
            INamedMemberAccessor accessor;
            if (!accessorCache.TryGetValue(key, out accessor) && accessor == null)
            {
                accessor = Activator.CreateInstance(typeof(PropertyAccessor<,>).MakeGenericType(type, type.GetProperty(memberName).PropertyType), type, memberName) as INamedMemberAccessor;
                Guard.ArgumentNotNull(accessor, "accessor");
                accessorCache.Add(key, accessor);
            }
            return accessor;
        }
    }
}

 

using System;

namespace XXX.Common
{
    /// <summary>
    /// Common guard clauses
    /// </summary>
    public static class Guard
    {
        /// <summary>
        /// Checks an argument to ensure it isn't null
        /// </summary>
        /// <param name="argumentValue">The argument value to check.</param>
        /// <param name="argumentName">The name of the argument.</param>
        public static void ArgumentNotNull(object argumentValue, string argumentName)
        {
            if (argumentValue == null)
            {
                var ex = new ArgumentNullException(argumentName);
            }
        }
    }
}