Question

I was using a custom method to deep clone objects the other day, and I know you can deep clone in different ways (reflection, binary serialization, etc), so I was just wondering:

What is/are the reason(s) that Microsoft does not include a deep copy method in the framework?

Answer 1

The problem is substantially harder than you seem to realize, at least in the general case.

For starters, a copy isn’t just deep or shallow, it’s a spectrum.

Let’s imagine for a second that we have a list of arrays of strings, and we want to make a copy of it.

• We start out at the shallowest level, we just copy the reference of the whole thing to another variable. Any changes to the list referenced from either variable is seen by the other.

• So now we go and create a brand new list to give to the second variable. For each item in the first list we add it to the second list. Now we can modify the list referenced from either variable without it being seen by the other one. But what if we grab the first item of a list and change the string that’s in the first array, it will be seen by both lists!

• Now we’re going through and creating a new list, and for each array in the first list we’re creating a new array, adding each of the strings in the underlying array to the new array, and adding each of those new arrays to the new list. Now we can mutate any of the arrays in either list without seeing the changes. But wait, both lists are still referencing the same strings (which are value types after all; they internally have a character array for their data). What if some mean person were to come along and mutate one of the strings (using unsafe code you could actually do this)! So now you’re copying all of the strings with a deep copy. But what if we don’t need to do that? What if we know that nobody is so mean that they would mutate the string? Or, for that matter, what if we know that none of the arrays will be mutated (or that if they will be, that they’re supposed to be reflected by both lists).

Then of course there are problems such as circular references, fields in a class that don’t really represent it’s state (i.e. possibly cached values or derived data that could just be re-calculated as-needed by a clone).

Realistically you’d need to have every type implement IClonable or some equivalent, and have it’s own custom code for how to clone itself. This would be a lot of work to maintain for a language, especially since there are so many ways that complex objects could possibly be cloned. The cost would be quite high, and the benefits (outside of a handful of objects that it is deemed worthwhile to implement clone methods for) are generally not worth it. You, as a programmer, and write your own logic for cloning a type based on how deep you know you need to go.