1、需求

在程式碼中經常會遇到需要把物件複製一遍，或者把屬性名相同的值複製一遍。

比如：

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

    public class StudentSecond
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public int Age { get; set; } 
    }
 

Student s = new Student() { Age = 20, Id = 1, Name = "Emrys" };

我們需要給新的Student賦值

Student ss = new Student { Age = s.Age, Id = s.Id, Name = s.Name };

再或者給另一個類StudentSecond的屬性賦值，兩個類屬性的名稱和型別一致。

StudentSecond ss = new StudentSecond { Age = s.Age, Id = s.Id, Name = s.Name };

2、解決辦法

當然最原始的辦法就是把需要賦值的屬性全部手動手寫。這樣的效率是最高的。但是這樣程式碼的重複率太高，而且程式碼看起來也不美觀，更重要的是浪費時間，如果一個類有幾十個屬性，那一個一個屬性賦值豈不是浪費精力，像這樣重複的勞動工作更應該是需要優化的。

2.1、反射

反射應該是很多人用過的方法，就是封裝一個類，反射獲取屬性和設定屬性的值。

 private static TOut TransReflection<TIn, TOut>(TIn tIn)
        {
            TOut tOut = Activator.CreateInstance<TOut>();
            var tInType = tIn.GetType();
            foreach (var itemOut in tOut.GetType().GetProperties())
            {
                var itemIn = tInType.GetProperty(itemOut.Name); ;
                if (itemIn != null)
                {
                    itemOut.SetValue(tOut, itemIn.GetValue(tIn));
                }
            }
            return tOut;
        }
 

呼叫：StudentSecond ss= TransReflection<Student, StudentSecond>(s);

呼叫一百萬次耗時：2464毫秒

2.2、序列化

序列化的方式有很多種，有二進位制、xml、json等等，今天我們就用Newtonsoft的json進行測試。

呼叫：StudentSecond ss= JsonConvert.DeserializeObject<StudentSecond>(JsonConvert.SerializeObject(s));

呼叫一百萬次耗時：2984毫秒

從這可以看出序列化和反射效率差別不大。

3、表示式樹

3.1、簡介

關於表示式樹不瞭解的可以百度。

也就是說複製物件也可以用表示式樹的方式。

        Expression<Func<Student, StudentSecond>> ss = (x) => new StudentSecond { Age = x.Age, Id = x.Id, Name = x.Name };
        var f = ss.Compile();
        StudentSecond studentSecond = f(s);

這樣的方式我們可以達到同樣的效果。

有人說這樣的寫法和最原始的複製沒有什麼區別，程式碼反而變多了呢，這個只是第一步。

3.2、分析程式碼

我們用ILSpy反編譯下這段表示式程式碼如下：

　　 ParameterExpression parameterExpression;
    Expression<Func<Student, StudentSecond>> ss = Expression.Lambda<Func<Student, StudentSecond>>(Expression.MemberInit(Expression.New(typeof(StudentSecond)), new MemberBinding[]
    {
        Expression.Bind(methodof(StudentSecond.set_Age(int)), Expression.Property(parameterExpression, methodof(Student.get_Age()))),
        Expression.Bind(methodof(StudentSecond.set_Id(int)), Expression.Property(parameterExpression, methodof(Student.get_Id()))),
        Expression.Bind(methodof(StudentSecond.set_Name(string)), Expression.Property(parameterExpression, methodof(Student.get_Name())))
    }), new ParameterExpression[]
    {
        parameterExpression
    });
    Func<Student, StudentSecond> f = ss.Compile();
    StudentSecond studentSecond = f(s);

那麼也就是說我們只要用反射迴圈所有的屬性然後Expression.Bind所有的屬性。最後呼叫Compile()(s)就可以獲取正確的StudentSecond。

看到這有的人又要問了，如果用反射的話那豈不是效率很低，和直接用反射或者用序列化沒什麼區別嗎？

當然這個可以解決的，就是我們的表示式樹可以快取。只是第一次用的時候需要反射，以後再用就不需要反射了。

3.3、複製物件通用程式碼

為了通用性所以其中的Student和StudentSecond分別泛型替換。

        private static Dictionary<string, object> _Dic = new Dictionary<string, object>();

        private static TOut TransExp<TIn, TOut>(TIn tIn)
        {
            string key = string.Format("trans_exp_{0}_{1}", typeof(TIn).FullName, typeof(TOut).FullName);
            if (!_Dic.ContainsKey(key))
            {
                ParameterExpression parameterExpression = Expression.Parameter(typeof(TIn), "p");
                List<MemberBinding> memberBindingList = new List<MemberBinding>();

                foreach (var item in typeof(TOut).GetProperties())
                {  
　　
　　　　　　　　　　　　if (!item.CanWrite)
　　　　　　　　　　　　　　continue; 
                    MemberExpression property = Expression.Property(parameterExpression, typeof(TIn).GetProperty(item.Name));
                    MemberBinding memberBinding = Expression.Bind(item, property);
                    memberBindingList.Add(memberBinding);
                }

                MemberInitExpression memberInitExpression = Expression.MemberInit(Expression.New(typeof(TOut)), memberBindingList.ToArray());
                Expression<Func<TIn, TOut>> lambda = Expression.Lambda<Func<TIn, TOut>>(memberInitExpression, new ParameterExpression[] { parameterExpression });
                Func<TIn, TOut> func = lambda.Compile();

                _Dic[key] = func;
            }
            return ((Func<TIn, TOut>)_Dic[key])(tIn);
        }

呼叫：StudentSecond ss= TransExp<Student, StudentSecond>(s);

呼叫一百萬次耗時：564毫秒

3.4、利用泛型的特性再次優化程式碼

不用字典儲存快取，因為泛型就可以很容易解決這個問題。

 public static class TransExpV2<TIn, TOut>
    {

        private static readonly Func<TIn, TOut> cache = GetFunc();
        private static Func<TIn, TOut> GetFunc()
        {
            ParameterExpression parameterExpression = Expression.Parameter(typeof(TIn), "p");
            List<MemberBinding> memberBindingList = new List<MemberBinding>();

            foreach (var item in typeof(TOut).GetProperties())
            {
　　　　　　　　　if (!item.CanWrite)
　　　　　　　　　　    continue;

                MemberExpression property = Expression.Property(parameterExpression, typeof(TIn).GetProperty(item.Name));
                MemberBinding memberBinding = Expression.Bind(item, property);
                memberBindingList.Add(memberBinding);
            }

            MemberInitExpression memberInitExpression = Expression.MemberInit(Expression.New(typeof(TOut)), memberBindingList.ToArray());
            Expression<Func<TIn, TOut>> lambda = Expression.Lambda<Func<TIn, TOut>>(memberInitExpression, new ParameterExpression[] { parameterExpression });

            return lambda.Compile();
        }

        public static TOut Trans(TIn tIn)
        {
            return cache(tIn);
        }

    }

呼叫：StudentSecond ss= TransExpV2<Student, StudentSecond>.Trans(s);

呼叫一百萬次耗時：107毫秒

耗時遠遠的小於使用automapper的338毫秒。 

4、總結

從以上的測試和分析可以很容易得出，用表示式樹是可以達到效率與書寫方式二者兼備的方法之一，總之比傳統的序列化和反射更加優秀。

轉自：https://www.cnblogs.com/lsgsanxiao/p/8205096.html