表达式树浅拷贝对象、反射浅拷贝对象对比手写的Copy方法100万次耗时对比（CPU是 i7 - 4710MQ）

static void Main(string[] args)
{
    
    var value = new TestClass
    {
    
        Age = 18,
        Name = "张三",
        Sex = Gender.Man
    };
    Console.WriteLine("-------手写代码------");
    for (int j = 0; j < 5; j++)
    {
    
        Stopwatch sw = Stopwatch.StartNew();
        for (int i = 0; i < 1000000; i++)
        {
    
            var copyValue = Copy(value);//手写的Copy
        }
        sw.Stop();
        Console.WriteLine("{0}ms", sw.Elapsed.TotalMilliseconds);
    }
    Console.WriteLine("-------表达式树------");
    for (int j = 0; j < 5; j++)
    {
    
        Stopwatch sw = Stopwatch.StartNew();
        for (int i = 0; i < 1000000; i++)
        {
    
            var copyValue = ShallowCopy<TestClass>.Copy(value);//表达式树实现的Copy【程序启动的第一次Copy需要编译会慢一点】
        }
        sw.Stop();
        Console.WriteLine("{0}ms", sw.Elapsed.TotalMilliseconds);
    }
    Console.WriteLine("-------反射生成------");
    for (int j = 0; j < 5; j++)
    {
    
        Stopwatch sw = Stopwatch.StartNew();
        for (int i = 0; i < 1000000; i++)
        {
    
            var copyValue = ShallowCopyReflect<TestClass>.Copy(value);//反射实现Copy
        }
        sw.Stop();
        Console.WriteLine("{0}ms", sw.Elapsed.TotalMilliseconds);
    }
}
public static TestClass Copy(TestClass value)
{
    
    return new TestClass
    {
    
        Age = value.Age,
        Name = value.Name,
        Sex = value.Sex
    };
}

public class TestClass
{
    
    public int Age {
     get; set; }
    public string Name {
     get; set; }
    public Gender Sex {
     get; set; }
}

public enum Gender
{
    
    Man = 0,
    Woman = 1
}

耗时：↓

-------手写代码------
42.7358ms
36.8807ms
35.0374ms
34.8473ms
35.1947ms
-------表达式树------
132.8095ms
132.7188ms
124.1226ms
124.3291ms
124.0487ms
-------反射生成------
2501.8246ms
2357.8119ms
2353.0715ms
2351.2028ms
2341.6874ms

表达式树Copy类

/// <summary>
/// 浅拷贝类
/// </summary>
/// <typeparam name="T">拷贝的类型</typeparam>
public static class ShallowCopy<T> where T : new()
{
    
    /// <summary>
    /// 浅拷贝委托对象树
    /// </summary>
    private static readonly Func<T, T> CopyFunc;

    static ShallowCopy()
    {
    
        var value = Expression.Parameter(typeof(T));
        var copyValue = Expression.New(typeof(T));
        var bindProValues = typeof(T).GetProperties().Where(w => w.CanWrite && w.CanRead).Select(pro => Expression.Bind(pro, Expression.Property(value, pro))).ToArray();
        var initProValue = Expression.MemberInit(copyValue, bindProValues);
        var lambda = Expression.Lambda<Func<T, T>>(initProValue, new[] {
     value });
        CopyFunc = lambda.Compile();
    }

    /// <summary>
    /// 拷贝方法
    /// </summary>
    /// <param name="value">需要被拷贝的值</param>
    /// <returns>拷贝的值</returns>
    public static T Copy(T value)
    {
    
        if (value == null) return default(T);
        return CopyFunc(value);
    }
}

反射实现的Copy类

/// <summary>
/// 浅拷贝类反射实现
/// </summary>
/// <typeparam name="T">拷贝的类型</typeparam>
public static class ShallowCopyReflect<T> where T : new()
{
    
    private readonly static PropertyInfo[] Properties;
    private readonly static ConstructorInfo Constructor;
    static ShallowCopyReflect()
    {
    
        Properties = typeof(T).GetProperties().Where(w => w.CanWrite && w.CanRead).ToArray();
        Constructor = typeof(T).GetConstructor(new Type[0]);
    }
    /// <summary>
    /// 拷贝方法
    /// </summary>
    /// <param name="value">需要被拷贝的值</param>
    /// <returns>拷贝的值</returns>
    public static T Copy(T value)
    {
    
        if (value == null) return default(T);
        var copyValue = Constructor.Invoke(null);
        foreach (var property in Properties)
        {
    
            property.SetValue(copyValue, property.GetValue(value));
        }
        return (T)copyValue;
    }
}