一、需求
在代碼中常常會遇到須要把對象複製一遍，或者把屬性名相同的值複製一遍。json
好比：緩存
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" };app
咱們須要給新的Student賦值post
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 };spa
二、解決辦法
固然最原始的辦法就是把須要賦值的屬性所有手動手寫。這樣的效率是最高的。可是這樣代碼的重複率過高，並且代碼看起來也不美觀，更重要的是浪費時間，若是一個類有幾十個屬性，那一個一個屬性賦值豈不是浪費精力，像這樣重複的勞動工做更應該是須要優化的。code
2.一、反射
反射應該是不少人用過的方法，就是封裝一個類，反射獲取屬性和設置屬性的值。orm
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);xml
調用一百萬次耗時：2464毫秒
2.二、序列化
序列化的方式有不少種，有二進制、xml、json等等，今天咱們就用Newtonsoft的json進行測試。
調用：StudentSecond ss= JsonConvert.DeserializeObject<StudentSecond>(JsonConvert.SerializeObject(s));
調用一百萬次耗時：2984毫秒
從這能夠看出序列化和反射效率差異不大。
三、表達式樹
3.一、簡介
關於表達式樹不瞭解的能夠百度。
也就是說複製對象也能夠用表達式樹的方式。
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.二、分析代碼
咱們用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.三、複製對象通用代碼
爲了通用性因此其中的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.四、利用泛型的特性再次優化代碼
不用字典存儲緩存，由於泛型就能夠很容易解決這個問題。
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毫秒。
四、總結
從以上的測試和分析能夠很容易得出，用表達式樹是能夠達到效率與書寫方式兩者兼備的方法之一，總之比傳統的序列化和反射更加優秀。
最後望對各位有所幫助，本文原創，歡迎拍磚和推薦。