(轉)C# 快速高效率復制對象的方式
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、總結
從以上的測試和分析可以很容易得出,用表達式樹是可以達到效率與書寫方式二者兼備的方法之一,總之比傳統的序列化和反射更加優秀。
最後望對各位有所幫助
借鑒之處:http://www.cnblogs.com/emrys5/
(轉)C# 快速高效率復制對象的方式