程序師世界是廣大編程愛好者互助、分享、學習的平台,程序師世界有你更精彩!
首頁
編程語言
C語言|JAVA編程
Python編程
網頁編程
ASP編程|PHP編程
JSP編程
數據庫知識
MYSQL數據庫|SqlServer數據庫
Oracle數據庫|DB2數據庫
 程式師世界 >> 編程語言 >> .NET網頁編程 >> C# >> C#入門知識 >> C# 快速高效率復制對象(表達式樹)

C# 快速高效率復制對象(表達式樹)

編輯:C#入門知識

C# 快速高效率復制對象(表達式樹)。本站提示廣大學習愛好者:(C# 快速高效率復制對象(表達式樹))文章只能為提供參考,不一定能成為您想要的結果。以下是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>();
   foreach (var itemOut in tOut.GetType().GetProperties())
   {
    var itemIn = tIn.GetType().GetProperties().Where(i => i.Name == itemOut.Name).FirstOrDefault();
    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())
    {
     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毫秒

4、總結

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

以上就是本文的全部內容,希望本文的內容對大家的學習或者工作能帶來一定的幫助,同時也希望多多支持!

  1. 上一頁:
  2. 下一頁:
Copyright © 程式師世界 All Rights Reserved