using System;
using System.Linq.Expressions;

namespace GetClassPropertyNameText
{
    /// <summary>
    /// 示例模型类
    /// </summary>
    public class Person
    {
        public string PersonName { get; set; }
        public DateTime Birthday { get; set; }
        public int Quantity { get; set; }
        public bool IsMarried { get; set; }
    }

    /// <summary>
    /// 帮助
    /// <![CDATA[
    /// http://stackoverflow.com/questions/4657311/reflection-get-property-name
    /// ]]>
    /// </summary>
    public class Helper
    {
        /// <summary>
        /// requires object instance, but you can skip specifying T
        /// <![CDATA[
        /// 示例:
        /// Person p = new Person();
        /// Helper.GetPropertyName(() => p.PersonName)
        /// ]]>
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="exp"></param>
        /// <returns></returns>
        public static string GetPropertyName<T>(Expression<Func<T>> exp)
        {
            return (((MemberExpression) (exp.Body)).Member).Name;
        }

        /// <summary>
        /// requires explicit specification of both object type and property type
        /// <![CDATA[
        /// 示例:
        /// Helper.GetPropertyName<Person,DateTime>(p => p.Birthday)
        /// ]]>
        /// </summary>
        /// <typeparam name="TObject"></typeparam>
        /// <typeparam name="TResult"></typeparam>
        /// <param name="exp"></param>
        /// <returns></returns>
        public static string GetPropertyName<TObject, TResult>(Expression<Func<TObject, TResult>> exp)
        {
            var me = exp.Body as MemberExpression;
            if (me != null)
            {
                return me.Member.Name;
            }
            return null;
        }

        /// <summary>
        /// requires explicit specification of object type
        /// </summary>
        /// <typeparam name="TObject"></typeparam>
        /// <param name="exp"></param>
        /// <returns></returns>
        public static string GetPropertyName<TObject>(Expression<Func<TObject, object>> exp)
        {
            return (((MemberExpression) (exp.Body)).Member).Name;
        }

    }

}

using System;
using System.Diagnostics;
using System.Linq.Expressions;
using System.Reflection;
using GetClassPropertyNameText;

namespace MuonLab.Commons.Reflection
{
    /// <summary>
    /// https://github.com/trullock/MuonKit/blob/master/src/MuonLab.Commons/Reflection/ReflectionHelper.cs
    /// https://github.com/trullock/MuonKit/blob/master/src/MuonLab.Commons.Tests/Reflection/GetPropertyName.cs
    /// <![CDATA[
    /// ReflectionHelper.GetPropertyName<TestClass, string>(t => t.Name)
    /// ReflectionHelper.GetPropertyName<TestClass, int>(t => t.InnerClass.Age)
    /// ]]>
    /// </summary>
    public static class ReflectionHelper
    {
        public static string GetPropertyName<T, TResult>(Expression<Func<T, TResult>> property)
        {
            var body = GetBody(property);
            return body.Member.Name;
        }

        public static MemberInfo GetMemberInfo<T, TResult>(Expression<Func<T, TResult>> property)
        {
            var body = GetBody(property);
            return body.Member;
        }

        public static TValue GetPropertyValue<TEntity, TValue>(TEntity entity, Expression<Func<TEntity, TValue>> property)
        {
            return property.Compile().Invoke(entity);
        }

        public static void SetPropertyValue<TEntity, TProperty>(TEntity entity, Expression<Func<TEntity, TProperty>> property, TProperty value)
        {
            typeof(TEntity).GetProperty(GetPropertyName(property)).SetValue(entity, value, null);
        }

        public static object GetPropertyValue(object obj, string propertyName)
        {
            return obj.GetType().GetProperty(propertyName).GetValue(obj, null);
        }

        public static string PropertyChainToString<TEntity, TResult>(Expression<Func<TEntity, TResult>> property, char delimeter)
        {
            var body = GetBody(property);
            return propertyChainToString(body.Expression, delimeter) + body.Member.Name;
        }

        public static string PropertyChainToString(Expression expression, char delimeter)
        {
            if (expression is LambdaExpression)
            {
                var memberExpression = expression as LambdaExpression;
                return propertyChainToString(memberExpression.Body, delimeter).TrimEnd(delimeter);
            }

            throw new NotSupportedException("Probably a nullable type, need implementing! Debug: " + expression);
        }

        private static string propertyChainToString(Expression expression, char delimeter)
        {
            if (expression is MemberExpression)
            {
                var exp = expression as MemberExpression;
                return propertyChainToString(exp.Expression, delimeter) + exp.Member.Name + delimeter;
            }
            if (expression is MethodCallExpression)
            {
                var exp = expression as MethodCallExpression;
                if (exp.Method.Name == "get_Item")
                {
                    var index = ((exp.Arguments[0] as MemberExpression).Member as FieldInfo).GetValue(((exp.Arguments[0] as MemberExpression).Expression as ConstantExpression).Value);

                    return (exp.Object as MemberExpression).Member.Name + "[" + index + "]" + delimeter;
                }
            }
            return string.Empty;
        }

        private static MemberExpression GetBody<TEntity, TResult>(Expression<Func<TEntity, TResult>> property)
        {
            if ((typeof(TResult).IsGenericType && typeof(TResult).GetGenericTypeDefinition().Equals(typeof(Nullable<>))) && property.Body is UnaryExpression)
            {
                var outerBody = property.Body as UnaryExpression;

                return outerBody.Operand as MemberExpression;
            }

            return property.Body as MemberExpression;
        }

        public static Expression<Func<T, TValue>> BuildGet<T, TValue>(PropertyInfo property)
        {
            Type type = typeof(T);
            ParameterExpression arg = Expression.Parameter(type, "x");
            var prop = Expression.Property(arg, property);

            return Expression.Lambda<Func<T, TValue>>(prop, arg);
        }

        public static bool MemberAccessExpressionsAreEqual<T, TProperty>(Expression<Func<T, TProperty>> expression1, Expression<Func<T, TProperty>> expression2)
        {
            return memberAccessExpressionsAreEqual(expression1.Body as MemberExpression, expression2.Body as MemberExpression);
        }

        private static bool memberAccessExpressionsAreEqual(MemberExpression expression1, MemberExpression expression2)
        {
            if (expression1 != null && expression2 != null)
                if (expression1.Member.Name == expression2.Member.Name)
                    return memberAccessExpressionsAreEqual(expression1.Expression as MemberExpression, expression2.Expression as MemberExpression);
                else
                    return false;
            else
                return true;
        }
    }

    /// <summary>
    /// 
    /// </summary>
    public class Test2
    {
        public void Test()
        {
            string s = ReflectionHelper.GetPropertyName<Person, string>(t => t.PersonName);
            Debug.WriteLine(s);
        }
    }
}