// 創(chuàng)建一個表達式樹表示 a + b
        ParameterExpression a = Expression.Parameter(typeof(int), "a");
        ParameterExpression b = Expression.Parameter(typeof(int), "b");
        BinaryExpression body = Expression.Add(a, b);
        // 編譯表達式樹為可執(zhí)行代碼
        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);//實現(xiàn)深克隆

interface ICloneHandler
{
    bool CanHandle(Type type);//是否可以處理當前類型
    Expression CreateCloneExpression(Expression original);//生成針對當前類型的表達式樹
}

public static class DeepCloneExtension
{
    //創(chuàng)建一個線程安全的緩存字典，復用表達式樹
    private static readonly ConcurrentDictionary<Type, Delegate> cloneDelegateCache = new ConcurrentDictionary<Type, Delegate>();
    //定義所有可處理的類型，通過策略模式實現(xiàn)了可擴展
    private static readonly List<ICloneHandler> handlers = new List<ICloneHandler>
    {
       //在此處添加自定義的類型處理器
    };
    /// <summary>
    /// 深克隆函數(shù)
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="original"></param>
    /// <returns></returns>
    public static T DeepClone<T>(this T original)
    {
        if (original == null)
            return default;
        // 獲取或創(chuàng)建克隆表達式
        var cloneFunc = (Func<T, T>)cloneDelegateCache.GetOrAdd(typeof(T), t => CreateCloneExpression<T>().Compile());
        //調(diào)用表達式，返回結(jié)果
        return cloneFunc(original);
    }
    /// <summary>
    /// 構(gòu)建表達式樹的主體邏輯
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <returns></returns>
    private static Expression<Func<T, T>> CreateCloneExpression<T>()
    {
        //反射獲取類型
        var type = typeof(T);
        // 創(chuàng)建一個類型為T的參數(shù)表達式 'x'
        var parameterExpression = Expression.Parameter(type, "x");
        // 創(chuàng)建一個成員綁定列表，用于稍后存放屬性綁定
        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;
            // 標記是否已經(jīng)處理過此屬性
            bool handled = false;
            // 遍歷所有處理器，查找可以處理當前屬性類型的處理器
            foreach (var handler in handlers)
            {
                // 如果找到合適的處理器，使用它來創(chuàng)建克隆表達式
                if (handler.CanHandle(property.PropertyType))
                {
                    valueExpression = handler.CreateCloneExpression(originalValue);
                    handled = true;
                    break;
                }
            }
            // 如果沒有找到處理器，則使用原始屬性值
            if (!handled)
            {
                valueExpression = originalValue;
            }
            // 創(chuàng)建屬性的綁定
            var binding = Expression.Bind(property, valueExpression);
            // 將綁定添加到綁定列表中
            bindings.Add(binding);
        }
        // 使用所有的屬性綁定來初始化一個新的T類型的對象
        var memberInitExpression = Expression.MemberInit(Expression.New(type), bindings);
        // 創(chuàng)建并返回一個表達式樹，它表示從輸入?yún)?shù) 'x' 到新對象的轉(zhuǎn)換
        return Expression.Lambda<Func<T, T>>(memberInitExpression, parameterExpression);
    }
}

class ArrayCloneHandler : ICloneHandler
{
    Type elementType;
    public bool CanHandle(Type type)
    {
        //數(shù)組類型要特殊處理獲取其內(nèi)部類型
        this.elementType = type.GetElementType();
        return type.IsArray;
    }
    public Expression CreateCloneExpression(Expression original)
    {
        //值類型或字符串，通過值類型數(shù)組賦值
        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);
        }
    }
    //引用類型數(shù)組賦值
    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]);//調(diào)用該類型的深克隆表達式
        }
        return clonedArray;
    }
    //值類型數(shù)組賦值
    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);
    }
}

private static readonly List<ICloneHandler> handlers = new List<ICloneHandler>
{
    new ArrayCloneHandler(),//數(shù)組
    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();