反射设置和获取值

using System;
using System.Reflection;
using System.Reflection.Emit;
/// <summary>
/// 属性值动态获取和赋值（get、set）
/// </summary>
public class PropertyUtil
{
    /// <summary>
    /// 反射获取对象的属性值
    /// </summary>
    /// <param name="obj"></param>
    /// <param name="propertyName"></param>
    /// <returns></returns>
    public static object ReflectGetter(object obj, string propertyName)
    {
        var type = obj.GetType();
        var propertyInfo = type.GetProperty(propertyName);
        var propertyValue = propertyInfo.GetValue(obj, null);
        return propertyValue;
    }


    /// <summary>
    /// 反射设置对象的属性值
    /// </summary>
    /// <param name="obj"></param>
    /// <param name="propertyName"></param>
    /// <param name="propertyValue"></param>
    public static void ReflectSetter(object obj, string propertyName, object propertyValue)
    {
        var type = obj.GetType();
        var propertyInfo = type.GetProperty(propertyName);
        propertyInfo.SetValue(obj, propertyValue, null);
    }

    /*
    /// <summary>
    /// 表达式获取对象的属性值
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="propertyName"></param>
    /// <returns></returns>
    public static Func<T, object> ExpresionGetter<T>(string propertyName)
    {
        var type = typeof(T);
        var property = type.GetProperty(propertyName);


         对象实例
        var parameterExpression = Expression.Parameter(typeof(object), "obj");


         转换参数为真实类型
        var unaryExpression = Expression.Convert(parameterExpression, type);


         调用获取属性的方法
        var callMethod = Expression.Call(unaryExpression, property.GetGetMethod());
        var expression = Expression.Lambda<Func<T, object>>(callMethod, parameterExpression);


        return expression.Compile();
    }
    public static object ExpresionGetterValue<T>(T model, string propertyName)
    {
        var setterMethod = ExpresionGetter<T>(propertyName);
        return setterMethod(model);
    }

    /// <summary>
    /// 表达式设置对象的属性值
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="propertyName"></param>
    /// <returns></returns>
    public static Action<T, object> ExpresionSetter<T>(string propertyName)
    {
        var type = typeof(T);
        var property = type.GetProperty(propertyName);


        var objectParameterExpression = Expression.Parameter(typeof(object), "obj");
        var objectUnaryExpression = Expression.Convert(objectParameterExpression, type);


        var valueParameterExpression = Expression.Parameter(typeof(object), "val");
        var valueUnaryExpression = Expression.Convert(valueParameterExpression, property.PropertyType);


         调用给属性赋值的方法
        var body = Expression.Call(objectUnaryExpression, property.GetSetMethod(), valueUnaryExpression);
        var expression = Expression.Lambda<Action<T, object>>(body, objectParameterExpression, valueParameterExpression);


        return expression.Compile();
    }
    public static void ExpresionSetterValue<T>(T model, string propertyName, object propertyValue)
    {
        var setterMethod = PropertyUtil.ExpresionSetter<T>(propertyName);
        setterMethod(model, propertyValue);
    }
    */
    /// <summary>
    /// Emit获取对象的属性值
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="propertyName"></param>
    /// <returns></returns>
    public static Func<T, object> EmitGetter<T>(string propertyName)
    {
        var type = typeof(T);


        var dynamicMethod = new DynamicMethod("get_" + propertyName, typeof(object), new[] { type }, type);
        var iLGenerator = dynamicMethod.GetILGenerator();
        iLGenerator.Emit(OpCodes.Ldarg_0);


        var property = type.GetProperty(propertyName);
        iLGenerator.Emit(OpCodes.Callvirt, property.GetGetMethod(true));


        if (property.PropertyType.IsValueType)
        {
            // 如果是值类型，装箱
            iLGenerator.Emit(OpCodes.Box, property.PropertyType);
        }
        else
        {
            // 如果是引用类型，转换
            iLGenerator.Emit(OpCodes.Castclass, property.PropertyType);
        }


        iLGenerator.Emit(OpCodes.Ret);


        return dynamicMethod.CreateDelegate(typeof(Func<T, object>)) as Func<T, object>;
    }

    public static object EmitGetterValue<T>(T model, string propertyName)
    {
        var setterMethod = PropertyUtil.EmitGetter<T>(propertyName);
        return setterMethod(model);
    }

    /// <summary>
    /// Emit设置对象的属性值
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="propertyName"></param>
    /// <returns></returns>
    public static Action<T, object> EmitSetter<T>(string propertyName)
    {
        var type = typeof(T);


        var dynamicMethod = new DynamicMethod("EmitCallable", null, new[] { type, typeof(object) }, type.Module);
        var iLGenerator = dynamicMethod.GetILGenerator();


        var callMethod = type.GetMethod("set_" + propertyName, BindingFlags.Instance | BindingFlags.IgnoreCase | BindingFlags.Public);
        var parameterInfo = callMethod.GetParameters()[0];
        var local = iLGenerator.DeclareLocal(parameterInfo.ParameterType, true);


        iLGenerator.Emit(OpCodes.Ldarg_1);
        if (parameterInfo.ParameterType.IsValueType)
        {
            // 如果是值类型，拆箱
            iLGenerator.Emit(OpCodes.Unbox_Any, parameterInfo.ParameterType);
        }
        else
        {
            // 如果是引用类型，转换
            iLGenerator.Emit(OpCodes.Castclass, parameterInfo.ParameterType);
        }


        iLGenerator.Emit(OpCodes.Stloc, local);
        iLGenerator.Emit(OpCodes.Ldarg_0);
        iLGenerator.Emit(OpCodes.Ldloc, local);


        iLGenerator.EmitCall(OpCodes.Callvirt, callMethod, null);
        iLGenerator.Emit(OpCodes.Ret);


        return dynamicMethod.CreateDelegate(typeof(Action<T, object>)) as Action<T, object>;
    }
    public static void EmitSetterValue<T>(T model, string propertyName, object propertyValue)
    {
        var setterMethod = PropertyUtil.EmitSetter<T>(propertyName);
        setterMethod(model, propertyValue);
    }
    public static void Test()
    {
        var model = new Logic();
        string testNameValue = "测试";
        string testNameproperty = "Name";

        int testAgeValue = 16;
        string testAgeproperty = "Age";

        // 设置 model 的 Name 字段值 = 测试
        PropertyUtil.ReflectSetter(model, testNameproperty, testNameValue);
        // 获取 model 的 Name 字段值
        var value = PropertyUtil.ReflectGetter(model, testNameproperty);
        if (value.ToString() != testNameValue)
        {

        }

        PropertyUtil.ReflectSetter(model, testAgeproperty, testAgeValue);
        // 获取 model 的 Age 字段值
        var valueAge = PropertyUtil.ReflectGetter(model, testAgeproperty);
        if (valueAge.ToString() != testAgeValue.ToString())
        {

        }

        /*
        var model2 = new Logic();
        // 设置 model 的 Name 字段值 = 测试
        var setterMethod = PropertyUtil.ExpresionSetter<Logic>(testNameproperty);
        setterMethod(model2, testNameValue);
        // 获取 model 的 Name 字段值
        var getterMethod = PropertyUtil.ExpresionGetter<Logic>(testNameproperty);
        var value2 = getterMethod(model2);
        if (value2.ToString() != testNameValue)
        {

        }
      
        // 设置 model 的 Age 字段值 = 测试
        var setterMethodAge = PropertyUtil.ExpresionSetter<Logic>(testAgeproperty);
        setterMethodAge(model2, testAgeValue);
        // 获取 model 的 Age 字段值
        var getterMethodAge = PropertyUtil.ExpresionGetter<Logic>(testAgeproperty);
        var valueAge2 = getterMethodAge(model2);
        if (valueAge2.ToString() != testAgeValue.ToString())
        {

        }
        */
        var model3 = new Logic();
        // 设置 model 的 Name 字段值 = 测试
        var setterMethod3 = PropertyUtil.EmitSetter<Logic>(testNameproperty);
        setterMethod3(model3, testNameValue);
        // 获取 model 的 Name 字段值
        var getterMethod3 = PropertyUtil.EmitGetter<Logic>(testNameproperty);
        var value3 = getterMethod3(model3);
        if (value3.ToString() != testNameValue)
        {

        }

        // 设置 model 的 Age 字段值 = 测试
        var setterMethodAge3 = PropertyUtil.EmitSetter<Logic>(testAgeproperty);
        setterMethodAge3(model3, testAgeValue);
        // 获取 model 的 Age 字段值
        var getterMethodAge3 = PropertyUtil.EmitGetter<Logic>(testAgeproperty);
        var valueAge3 = getterMethodAge3(model3);
        if (valueAge3.ToString() != testAgeValue.ToString())
        {

        }
    }
    public static void Test2()
    {
        string testNameValue = "测试";
        string testNameproperty = "Name";

        int testAgeValue = 16;
        string testAgeproperty = "Age";

        var model = new Logic();

        // 设置 model 的 Name 字段值 = 测试
        PropertyUtil.ReflectSetter(model, testNameproperty, testNameValue);
        // 获取 model 的 Name 字段值
        var value = PropertyUtil.ReflectGetter(model, testNameproperty);
        if (value.ToString() != testNameValue)
        {

        }
        // 设置 model 的 Age 字段值 = 测试
        PropertyUtil.ReflectSetter(model, testAgeproperty, testAgeValue);
        // 获取 model 的 Age 字段值
        var valueAge = PropertyUtil.ReflectGetter(model, testAgeproperty);
        if (valueAge.ToString() != testAgeValue.ToString())
        {

        }

        /*
        var model2 = new Logic();
        // 设置 model 的 Name 字段值 = 测试
        PropertyUtil.ExpresionSetterValue<Logic>(model2, testNameproperty, testNameValue);

        // 获取 model 的 Name 字段值
        var value2 = PropertyUtil.ExpresionGetterValue<Logic>(model2, testNameproperty);
        if (value2.ToString() != testNameValue)
        {

        }
        // 设置 model 的 Age 字段值 = 测试
        PropertyUtil.ExpresionSetterValue<Logic>(model2, testAgeproperty, testAgeValue);
        
        // 获取 model 的 Age 字段值
        var valueAge2 = PropertyUtil.ExpresionGetterValue<Logic>(model2, testAgeproperty);
        if (valueAge2.ToString() != testAgeValue.ToString())
        {

        }
        */
        var model3 = new Logic();
        // 设置 model 的 Name 字段值 = 测试
        EmitSetterValue<Logic>(model3, testNameproperty, testNameValue);

        // 获取 model 的 Name 字段值
        var value3 = PropertyUtil.EmitGetterValue<Logic>(model3, testNameproperty);
        if (value3.ToString() != testNameValue)
        {

        }
        // 设置 model 的 Age 字段值 = 测试
        EmitSetterValue<Logic>(model3, testAgeproperty, testAgeValue);

        // 获取 model 的 Age 字段值
        var valueAge3 = PropertyUtil.EmitGetterValue<Logic>(model3, testAgeproperty);
        if (valueAge3.ToString() != testAgeValue.ToString())
        {

        }
    }

    public class Logic
    {
        /// <summary>
        /// 
        /// </summary>
        public string Name { get; set; }

        public int Age { get; set; }
    }
}