一、表達式樹的基本概念
表達式樹是一個以樹狀結構表示的表達式，其中每個節點都代表表達式的一部分。例如，一個算術表達式 a + b 可以被表示爲一個樹，其中根節點是加法運算符，它的兩個子節點分別是 a 和 b。在 LINQ（語言集成查詢）中，表達式樹使得能夠將 C# 中的查詢轉換成其他形式的查詢，比如 SQL 查詢。這樣，同樣的查詢邏輯可以用於不同類型的數據源，如數據庫、XML 文件等。由於表達式樹可以在運行時創建和修改，同樣的它們非常適合需要根據運行時數據動態生成或改變代碼邏輯的場景。這對於需要重複執行的邏輯（比如本文提到的深克隆）是非常有用的，因爲它們可以被優化和緩存，從而提高效率。
二、創建和使用表達式樹
在 C# 中，我們可以通過 System.Linq.Expressions 命名空間中的類來創建和操作表達式樹。以下是一個創建簡單表達式樹的示例：
// 創建一個表達式樹表示 a + b ParameterExpression a = Expression.Parameter(typeof(int), "a"); ParameterExpression b = Expression.Parameter(typeof(int), "b"); BinaryExpression body = Expression.Add(a, b); // 編譯表達式樹爲可執行代碼 var add = Expression.Lambda<Func<int, int, int>>(body, a, b).Compile(); // 使用表達式 Console.WriteLine(add(1, 2)); // 輸出 3
當我們定義了一個類型後，我們可以通過一個匿名委託進行值拷貝來實現深克隆：
//自定義類型 public class TestDto { public int Id { get; set; } public string Name { get; set; } } //匿名委託 Func<TestDto, TestDto> deepCopy = x => new TestDto() { Id = x.Id, Name = x.Name }; //使用它 var a =new TestDto(){//賦值}; var b = deepCopy(a);//實現深克隆
那麼想要自動化的創建這一匿名委託就會用到表達式樹，通過自動化的方式來實現匿名委託的自動化創建，這樣就可以實現複雜的自動化表達式創建從而不必依賴反射、序列化/反序列化等等比較消耗性能的方式來實現。核心的業務邏輯部分如下：首先我們需要知道表達式樹通過反射來遍歷對象的屬性，來實現x = old.x這樣的賦值操作。而對於不同的屬性比如數組、字典、值類型、自定義類、字符串，其賦值方案是不同的，簡單的值類型和字符串我們可以直接通過=賦值，因爲這兩者的賦值都是“深”克隆。也就是賦值後的變量修改不會影響原始變量。而複雜的字典、數組、對象如果使用=賦值，則只會得到對象的引用，所以針對不同的情況需要不同的處理。
首先我們需要定義一個接口ICloneHandler，針對不同情況使用繼承該接口的處理類來處理：
interface ICloneHandler { bool CanHandle(Type type);//是否可以處理當前類型 Expression CreateCloneExpression(Expression original);//生成針對當前類型的表達式樹 }
接着我們定義一個擴展類和擴展函數，用於處理深拷貝：
public static class DeepCloneExtension { //創建一個線程安全的緩存字典，複用表達式樹 private static readonly ConcurrentDictionary<Type, Delegate> cloneDelegateCache = new ConcurrentDictionary<Type, Delegate>(); //定義所有可處理的類型，通過策略模式實現了可擴展 private static readonly List<ICloneHandler> handlers = new List<ICloneHandler> { //在此處添加自定義的類型處理器 }; /// <summary> /// 深克隆函數 /// </summary> /// <typeparam name="T"></typeparam> /// <param name="original"></param> /// <returns></returns> public static T DeepClone<T>(this T original) { if (original == null) return default; // 獲取或創建克隆表達式 var cloneFunc = (Func<T, T>)cloneDelegateCache.GetOrAdd(typeof(T), t => CreateCloneExpression<T>().Compile()); //調用表達式，返回結果 return cloneFunc(original); } /// <summary> /// 構建表達式樹的主體邏輯 /// </summary> /// <typeparam name="T"></typeparam> /// <returns></returns> private static Expression<Func<T, T>> CreateCloneExpression<T>() { //反射獲取類型 var type = typeof(T); // 創建一個類型爲T的參數表達式 'x' var parameterExpression = Expression.Parameter(type, "x"); // 創建一個成員綁定列表，用於稍後存放屬性綁定 var bindings = new List<MemberBinding>(); // 遍歷類型T的所有屬性，選擇可讀寫的屬性 foreach (var property in type.GetProperties().Where(prop => prop.CanRead && prop.CanWrite)) { // 獲取原始屬性值的表達式 var originalValue = Expression.Property(parameterExpression, property); // 初始化一個表達式用於存放可能處理過的屬性值 Expression valueExpression = null; // 標記是否已經處理過此屬性 bool handled = false; // 遍歷所有處理器，查找可以處理當前屬性類型的處理器 foreach (var handler in handlers) { // 如果找到合適的處理器，使用它來創建克隆表達式 if (handler.CanHandle(property.PropertyType)) { valueExpression = handler.CreateCloneExpression(originalValue); handled = true; break; } } // 如果沒有找到處理器，則使用原始屬性值 if (!handled) { valueExpression = originalValue; } // 創建屬性的綁定 var binding = Expression.Bind(property, valueExpression); // 將綁定添加到綁定列表中 bindings.Add(binding); } // 使用所有的屬性綁定來初始化一個新的T類型的對象 var memberInitExpression = Expression.MemberInit(Expression.New(type), bindings); // 創建並返回一個表達式樹，它表示從輸入參數 'x' 到新對象的轉換 return Expression.Lambda<Func<T, T>>(memberInitExpression, parameterExpression); } }
接下來我們就可以添加一些常見的類型處理器：
數組處理：
class ArrayCloneHandler : ICloneHandler { Type elementType; public bool CanHandle(Type type) { //數組類型要特殊處理獲取其內部類型 this.elementType = type.GetElementType(); return type.IsArray; } public Expression CreateCloneExpression(Expression original) { //值類型或字符串，通過值類型數組賦值 if (elementType.IsValueType || elementType == typeof(string)) { return Expression.Call(GetType().GetMethod(nameof(DuplicateArray), BindingFlags.NonPublic | BindingFlags.Static).MakeGenericMethod(elementType), original); } //否則使用引用類型賦值 else { var arrayCloneMethod = GetType().GetMethod(nameof(CloneArray), BindingFlags.NonPublic | BindingFlags.Static).MakeGenericMethod(elementType); return Expression.Call(arrayCloneMethod, original); } } //引用類型數組賦值 static T[] CloneArray<T>(T[] originalArray) where T : class, new() { if (originalArray == null) return null; var length = originalArray.Length; var clonedArray = new T[length]; for (int i = 0; i < length; i++) { clonedArray[i] = DeepClone(originalArray[i]);//調用該類型的深克隆表達式 } return clonedArray; } //值類型數組賦值 static T[] DuplicateArray<T>(T[] originalArray) { if (originalArray == null) return null; T[] clonedArray = new T[originalArray.Length]; Array.Copy(originalArray, clonedArray, originalArray.Length); return clonedArray; } }
自定義類型處理(其實就是調用該類型的深克隆)：
class ClassCloneHandler : ICloneHandler { Type elementType; public bool CanHandle(Type type) { this.elementType = type; return type.IsClass && type != typeof(string); } public Expression CreateCloneExpression(Expression original) { var deepCloneMethod = typeof(DeepCloneExtension).GetMethod(nameof(DeepClone), BindingFlags.Public | BindingFlags.Static).MakeGenericMethod(elementType); return Expression.Call(deepCloneMethod, original); } }
接着我們就可以在之前的DeepCloneExtension中添加這些handles
private static readonly List<ICloneHandler> handlers = new List<ICloneHandler> { new ArrayCloneHandler(),//數組 new DictionaryCloneHandler(),//字典 new ClassCloneHandler()//類 ... };
最後我們可以通過簡單的進行調用就可以實現深克隆了
var a = new TestDto() { Id = 1, Name = "小明", Child = new TestDto() { Id = 2, Name = "小紅" }, Record = new Dictionary<string, int>() { { "1年級", 1 }, { "2年級", 2 } }, Scores = [100, 95] }; var b = a.DeepClone();
總之，C# 的表達式樹提供了一個強大的機制，可以將代碼以數據結構的形式表示出來，使得代碼可以在運行時進行檢查、修改或執行。這爲動態查詢生成、代碼優化和動態編程提供了很多可能性。