这里提供一个可以深拷贝字典的示例:
using Newtonsoft.Json;
namespace DemoApp1;
internal class Program
{
private static void Main(string[] args)
{
var b1 = new Box();
var b3 = new Box();
b1.Length = 1;
b1.Breadth = 1;
b1.Height = 1;
b1.Properties = new Dictionary<string, Box> { { "xfd", b3 } };
var b2 = b1.Copy();
b2.Breadth = 2;
var list = new List<Box>();
Console.WriteLine(b1.Breadth);
Console.WriteLine(b2.Breadth);
list.AddRange(new[] { b1, b2, b3 });
Console.WriteLine(JsonConvert.SerializeObject(list));
Console.ReadKey();
}
}
public class Box
{
public double Length; // 长度
public double Breadth; // 宽度
public double Height; // 高度
public Dictionary<string, Box> Properties { get; set; }
}
运行结果:
1
2
[{"Length":1.0,"Breadth":1.0,"Height":1.0,"Properties":{"xfd":{"Length":0.0,"Breadth":0.0,"Height":0.0,"Properties":null}}},{"Length":1.0,"Breadth":2.0,"Height":1.0,"Properties":{"xfd":{"Length":0.0,"Breadth":0.0,"Height":0.0,"Properties":null}}},{"Length":0.0,"Breadth":0.0,"Height":0.0,"Properties":null}]
ObjectExtensions.cs类和相关的静态扩展方法如下:
using DemoApp1.ArrayExtensions;
using System.Reflection;
namespace DemoApp1
{
public static class ObjectExtensions
{
private static readonly MethodInfo CloneMethod = typeof(object).GetMethod("MemberwiseClone", BindingFlags.NonPublic | BindingFlags.Instance);
public static bool IsPrimitive(this Type type)
{
if (type == typeof(string)) return true;
return (type.IsValueType & type.IsPrimitive);
}
public static object Copy(this object originalObject)
{
return InternalCopy(originalObject, new Dictionary<object, object>(new ReferenceEqualityComparer()));
}
private static object InternalCopy(object originalObject, IDictionary<object, object> visited)
{
if (originalObject == null) return null;
var typeToReflect = originalObject.GetType();
if (IsPrimitive(typeToReflect)) return originalObject;
if (visited.ContainsKey(originalObject)) return visited[originalObject];
if (typeof(Delegate).IsAssignableFrom(typeToReflect)) return null;
var cloneObject = CloneMethod.Invoke(originalObject, null);
if (typeToReflect.IsArray)
{
var arrayType = typeToReflect.GetElementType();
if (IsPrimitive(arrayType) == false)
{
var clonedArray = (Array)cloneObject;
clonedArray.ForEach((array, indices) => array.SetValue(InternalCopy(clonedArray.GetValue(indices), visited), indices));
}
}
visited.Add(originalObject, cloneObject);
CopyFields(originalObject, visited, cloneObject, typeToReflect);
RecursiveCopyBaseTypePrivateFields(originalObject, visited, cloneObject, typeToReflect);
return cloneObject;
}
private static void RecursiveCopyBaseTypePrivateFields(object originalObject, IDictionary<object, object> visited, object cloneObject, Type typeToReflect)
{
if (typeToReflect.BaseType == null) return;
RecursiveCopyBaseTypePrivateFields(originalObject, visited, cloneObject, typeToReflect.BaseType);
CopyFields(originalObject, visited, cloneObject, typeToReflect.BaseType, BindingFlags.Instance | BindingFlags.NonPublic, info => info.IsPrivate);
}
private static void CopyFields(object originalObject, IDictionary<object, object> visited, object cloneObject, IReflect typeToReflect, BindingFlags bindingFlags = BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.FlattenHierarchy, Func<FieldInfo, bool> filter = null)
{
foreach (var fieldInfo in typeToReflect.GetFields(bindingFlags))
{
if (filter != null && filter(fieldInfo) == false) continue;
if (IsPrimitive(fieldInfo.FieldType)) continue;
var originalFieldValue = fieldInfo.GetValue(originalObject);
var clonedFieldValue = InternalCopy(originalFieldValue, visited);
fieldInfo.SetValue(cloneObject, clonedFieldValue);
}
}
public static T Copy<T>(this T original)
{
return (T)Copy((object)original);
}
}
public class ReferenceEqualityComparer : EqualityComparer<Object>
{
public override bool Equals(object x, object y)
{
return ReferenceEquals(x, y);
}
public override int GetHashCode(object obj)
{
return obj.GetHashCode();
}
}
namespace ArrayExtensions
{
public static class ArrayExtensions
{
public static void ForEach(this Array array, Action<Array, int[]> action)
{
if (array.LongLength == 0) return;
var walker = new ArrayTraverse(array);
do action(array, walker.Position);
while (walker.Step());
}
}
internal class ArrayTraverse
{
public int[] Position;
private readonly int[] _maxLengths;
public ArrayTraverse(Array array)
{
_maxLengths = new int[array.Rank];
for (var i = 0; i < array.Rank; ++i)
{
_maxLengths[i] = array.GetLength(i) - 1;
}
Position = new int[array.Rank];
}
public bool Step()
{
for (var i = 0; i < Position.Length; ++i)
{
if (Position[i] >= _maxLengths[i]) continue;
Position[i]++;
for (var j = 0; j < i; j++)
{
Position[j] = 0;
}
return true;
}
return false;
}
}
}
}