在代码中经常会遇到需要把东西复制一遍，或者把属性名不异的值复制一遍。
好比：
1 public class Student 2 { 3 public int Id { get; set; } 4 public string Name { get; set; } 5 public int Age { get; set; } 6 } 7 8 public class StudentSecond 9 { 10 public int Id { get; set; } 11 public string Name { get; set; } 12 public int Age { get; set; } 13 }
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、反射反射应该是很多人用过的要领，就是封装一个类，反射获取属性和设置属性的值。
1 private static TOut TransReflection<TIn, TOut>(TIn tIn) 2 { 3 TOut tOut = Activator.CreateInstance<TOut>(); 4 var tInType = tIn.GetType(); 5 foreach (var itemOut in tOut.GetType().GetProperties()) 6 { 7 var itemIn = tInType.GetProperty(itemOut.Name); ; 8 if (itemIn != null) 9 { 10 itemOut.SetValue(tOut, itemIn.GetValue(tIn)); 11 } 12 } 13 return tOut; 14 }
挪用：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、简介关于表达式树不了解的可以百度。
也就是说复制东西也可以用表达式树的方法。
1 Expression<Func<Student, StudentSecond>> ss = (x) => new StudentSecond { Age = x.Age, Id = x.Id, Name = x.Name }; 2 var f = ss.Compile(); 3 StudentSecond studentSecond = f(s);
这样的方法我们可以到达同样的效果。
有人说这样的写法和最原始的复制没有什么区别，代码反而变多了呢，这个只是第一步。
3.2、分析代码我们用ILSpy反编译下这段表达式代码如下：
1 ParameterExpression parameterExpression; 2 Expression<Func<Student, StudentSecond>> ss = Expression.Lambda<Func<Student, StudentSecond>>(Expression.MemberInit(Expression.New(typeof(StudentSecond)), new MemberBinding[] 3 { 4 Expression.Bind(methodof(StudentSecond.set_Age(int)), Expression.Property(parameterExpression, methodof(Student.get_Age()))), 5 Expression.Bind(methodof(StudentSecond.set_Id(int)), Expression.Property(parameterExpression, methodof(Student.get_Id()))), 6 Expression.Bind(methodof(StudentSecond.set_Name(string)), Expression.Property(parameterExpression, methodof(Student.get_Name()))) 7 }), new ParameterExpression[] 8 { 9 parameterExpression 10 }); 11 Func<Student, StudentSecond> f = ss.Compile(); 12 StudentSecond studentSecond = f(s);
那么也就是说我们只要用反射循环所有的属性然后Expression.Bind所有的属性。最后挪用Compile()(s)就可以获取正确的StudentSecond。
看到这有的人又要问了，如果用反射的话那岂不是效率很低，和直接用反射或者用序列化没什么区别吗？