If the deep replication of objects is realized through C ＃?

Consultation area

• NakedBrunch

I want to achieve Reference type objects Deep replication between , That is, modifying the new object will not affect the old object , I used it C# Provided Clone Method .

MyObject myObj = GetMyObj(); // Create and fill a new object
MyObject newObj = myObj.Clone();

But it doesn't seem to work , How to correctly realize ？

Answer area

• craastad

If your Reference type objects yes json Amicable , Then you can turn it into... With the help of third-party tools Json, such as Json.NET , Refer to the following Clone Extension method .

public static T Clone<T>(this T theObject)
{
    string jsonData = JsonConvert.SerializeObject(theObject);
    return JsonConvert.DeserializeObject<T>(jsonData);
}

Then use it as follows .

NewObject = OldObject.Clone();

• Stacked

If you want to achieve , It is recommended to use the object mapping tool AutoMapper, It is an efficient and lightweight way to turn one object into another , Its bottom layer uses Lambda Expression tree , Refer to the following code ：

MyType source = new MyType();
Mapper.CreateMap<MyType, MyType>();
MyType target = Mapper.Map<MyType, MyType>(source);

above target It's deep copy After the object , If you think it's cumbersome , Then encapsulated in an extension method .

public static T Copy<T>(this T source)
{
    T copy = default(T);
    Mapper.CreateMap<T, T>();
    copy = Mapper.Map<T, T>(source);
    return copy;
}

Then use it as follows .

MyType copy = source.Copy();

• Marcell Toth

Generally speaking , Do deep copy, The methods are as follows .

1. serialize

In essence , Serialization is a very slow way , And there are many restrictions , for instance ：

1. BinaryFormatter The reference type required must implement Serializable characteristic .

2. JsonConverter The reference type must have a parameterless constructor .

1. Expression tree

Speed up first , have access to Expression Tree perhaps Reflection.Emit To dynamically generate deep copy code , But this primitive approach is particularly troublesome , I wrote a mapping tool for this purpose , See github：https://github.com/marcelltoth/ObjectCloner

It's very convenient to implement , Refer to the following code ：

var clone = ObjectCloner.DeepClone(original);

My method ~3x On Reflection, ~12x On Newtonsoft.Json .

Comment area

Actually Dapper It's used Emit To achieve high-speed mapping , AutoMapper It's using Expresstion Tree Achieve high-speed mapping , If you are interested, you can understand .