代码如下:
/// <summary>
/// 提供对象或集合的深拷贝(拷贝private/public:实例成员、属性、静态成员)
/// </summary>
/// <typeparam name="T">对象类型或集合元素类型</typeparam>
public class DeepCopyHelper<T> where T : class, new() // 需要无参构造函数,构造表达式树的时候需要利用无参构造函数创建对象
{
/// <summary>
/// 映射表达式,泛型缓存每个类型存一份
/// </summary>
private static readonly Func<T, T> s_CopyFunc = null;
/// <summary>
/// 静态构造函数,每个泛型类型会且只会执行一次
/// </summary>
static DeepCopyHelper()
{
BindingFlags bindingFlags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
ParameterExpression parameterExpression = Expression.Parameter(typeof(T), "m"); // 参数m :m =>
List<MemberBinding> memberBindingList = new List<MemberBinding>();
foreach (var item in typeof(T).GetProperties(bindingFlags))
{
if (!item.CanWrite) // 只读属性不拷贝
{
continue;
}
MemberExpression property = Expression.Property(parameterExpression, item); // m.Name
MemberBinding memberBinding = Expression.Bind(item, property); // Name = m.Name
memberBindingList.Add(memberBinding);
}
foreach (var item in typeof(T).GetFields(bindingFlags))
{
MemberExpression property = Expression.Field(parameterExpression, item);
MemberBinding memberBinding = Expression.Bind(item, property);
memberBindingList.Add(memberBinding);
}
MemberInitExpression memberInitExpression = Expression.MemberInit(Expression.New(typeof(T)), memberBindingList.ToArray());// new T() {Name = m.Name}
Expression<Func<T, T>> lambda = Expression.Lambda<Func<T, T>>(memberInitExpression, new ParameterExpression[]
{
parameterExpression
}); // m => new T() {Name = m.Name}
s_CopyFunc = lambda.Compile();
}
/// <summary>
/// 对象拷贝(拷贝private/public:实例成员、属性、静态成员)
/// </summary>
/// <param name="data">源</param>
/// <returns></returns>
public static T DeepCopy(T data)
{
return s_CopyFunc(data);
}
/// <summary>
/// 集合拷贝(拷贝private/public:实例成员、属性、静态成员)
/// </summary>
/// <param name="data">源</param>
/// <returns></returns>
public static List<T> DeepCopyList(List<T> data)
{
if (data == null)
{
return null;
}
if (data.Count == 0)
{
return new List<T>();
}
return data.Select(a => DeepCopy(a)).ToList();
}
}
有一种深拷贝方式,是利用BinaryFormatter序列化再反序列化,如下:
public static class ObjectExtension
{
/// <summary>
/// 深拷贝
/// 注意:必须标识为可序列化[Serializable]
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="obj"></param>
/// <returns></returns>
public static T DeepCopy<T>(this T obj)
where T : class
{
try
{
if (obj == null)
{
return null;
}
BinaryFormatter binaryFormatter = new BinaryFormatter();
using (MemoryStream stream = new MemoryStream())
{
binaryFormatter.Serialize(stream, obj);
stream.Position = 0;
return (T)binaryFormatter.Deserialize(stream);
}
}
catch
{
return null;
}
}
}
以下面的People类为例
[Serializable]
public class People
{
public People() { }
public People(Guid id, int name1, int name2, int name3, int name4, string uniqueName)
{
ID = id;
Name1 = name1;
Name2 = name2;
Name3 = name3;
Name4 = name4;
UniqueName = uniqueName;
}
private Guid ID;
private string UniqueName;
private int Name1;
private int Name2 { get; set; }
public int Name3;
public int Name4 { get; set; }
}
分别对List<People>集合进行深拷贝测试:
//测试集合拷贝
// 创建包含一定数量元素的集合
int count = 100; // 可设置不同量级的数量进行对比
List<People> lstSource = new List<People>();
for (int i = 0; i < count; i++)
{
lstSource.Add(new People(Guid.NewGuid(), i, i + 1, i + 2, i + 3, "测试"));
}
Console.WriteLine("数据量:" + lstSource.Count);
// 对比
Stopwatch watch = new Stopwatch();
watch.Start();
List<People> lstCopy = DeepCopyFactory<People>.DeepCopyList(lstSource);
watch.Stop();
Console.WriteLine("新的方式:" + watch.ElapsedMilliseconds + "毫秒");
watch.Restart();
List<People> lstCopy2 = lstSource.DeepCopy();
watch.Stop();
Console.WriteLine("BinaryFormatter序列化方式:" + watch.ElapsedMilliseconds + "毫秒");
Console.Read();
对比结果如下:
可见,这种方式,数据量越大,效果越明显。
像上边的People类,一千万的数据深拷贝。只需2s
=============================
2020-11-17更新,
深拷贝不拷贝只读属性,更新了代码。
2020-12-9 更新
静态字段不反射,静态字段属于类