深拷贝 引用对象复制 DeepCopy

返回一个自身的完全克隆对象;

    public static class CopyBySerialize<T>
    {
        public static T Copy(T instnace)
        {
            using (MemoryStream ms = new MemoryStream())
            {
                System.Runtime.Serialization.IFormatter formatter = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
                formatter.Serialize(ms, instnace);
                ms.Seek(0, SeekOrigin.Begin);
                return (T)formatter.Deserialize(ms);
            }
        }
    }

测试结果:

public void TestCopy()
{
    ResultData result = new ResultData();
    result.ID = 100.1;
    Console.WriteLine($"被克隆对象{result.ID}");

    ResultData CopyResult = CopyBySerialize<ResultData>.Copy(result);

    Console.WriteLine($"克隆的对象{CopyResult.ID}");
    CopyResult.ID = 10.1;
    Console.WriteLine("修改后");
    Console.WriteLine($"{result.ID}");
    Console.WriteLine($"{CopyResult.ID}");
}


结果:

被克隆对象100.1
克隆的对象100.1
修改后
100.1
10.1

注意，使用二进制序列化和反序列化时，在需要序列化的类上要加上[Serializable]

其他方法

1.序列化再反序列化:

public static T DeepCopyJson<T>(T obj)
{
    return JsonConvert.DeserializeObject<T>(JsonConvert.SerializeObject(obj));
}

2.AutoMapper

//创建MapperConfig
var config = new MapperConfiguration(cfg => cfg.CreateMap<UserInfo, UserInfo>());
var mapper = config.CreateMapper();

//调用
UserInfo newInfo = mapper.Map<UserInfo>(info);

3.表达式树

先反射获取字段缓存起来，再用表达式树赋值,性能佳

public static class TransExp<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);
    }
}


//调用
UserInfo newInfo = TransExp<UserInfo, UserInfo>.Trans(info);