采用表达式树(Expression Tree)对一个对象的属性进行“遍历”

public class Student
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public Location Location { get; set; }
    } 


    public class Location 
    { 
        public int Row { get; set; } 
        public int Col { get; set; } 
    }

using System;
using System.Linq.Expressions;
using System.Reflection;
namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            object student = new Student
            {
                Id = 1,
                Name = "zhang san",
                Location = new Location
                {
                    Row = 10,
                    Col = 20
                }
            };
           VisitProperties<Student>(student);
        }

        /// <summary>
        /// 对未知类型的对象的属性进行递归访问
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="obj"></param>
        static void VisitProperties<T>(object obj)
        {
            var type = obj.GetType();
            var paraExpression = Expression.Parameter(typeof(T), "object");
            foreach (var prop in type.GetProperties())
            {
                var propType = prop.PropertyType;
                //判断是否为基本类型或String
                //访问方式的表达式树为：obj =>obj.Property
                if (propType.IsPrimitive || propType == typeof (String))
                {
                    VisitProperty<T>(obj, prop, paraExpression, paraExpression);
                }
                    
                else
                {
                    //对于访问方式的表达式树为： obj=>obj.otherObj.Property。

                    Console.WriteLine("not primitive property: " + prop.Name);
                    var otherType = prop.PropertyType;
                    MemberExpression memberExpression = Expression.Property(paraExpression, prop);
                    //访问obj.otherObj里的所有公有属性
                    foreach (var otherProp in otherType.GetProperties())
                    {
                        VisitProperty<T>(obj, otherProp, memberExpression, paraExpression);
                    }
                }
                Console.WriteLine("--------------------------------");
            }
        }

        /// <summary>
        /// 执行表达式树为： obj=>obj.Property 或 obj=>obj.otherObj.Property的计算
        /// </summary>
        /// <param name="instanceExpression">最终访问属性的obj对象的表达式树的表示</param>
        /// <param name="parameterExpression">类型T的参数表达式树的表示</param>
        static void VisitProperty<T>(Object obj, PropertyInfo prop, Expression instanceExpression, ParameterExpression parameterExpression)
        {
            Console.WriteLine("property name: " + prop.Name);

            MemberExpression memExpression = Expression.Property(instanceExpression, prop);
            //实现类型转换，如将Id的int类型转为object类型，便于下面的通用性
            Expression objectExpression = Expression.Convert(memExpression, typeof(object));
            Expression<Func<T, object>> lambdaExpression = Expression.Lambda<Func<T, object>>(objectExpression, parameterExpression);
            //打印表达式树
            Console.WriteLine("expression tree: " + lambdaExpression);
            Func<T, object> func = lambdaExpression.Compile();
            Console.WriteLine("value: " + func((T)obj)); //打印出得到的属性值
        }
    }

}