How to make a shallow copy of an array?

Question

I pass a two-dimensional array as a property to my user control. There I store this values in another two-dimensional array:

int[,] originalValues = this.Metrics;

Later, I change values in this.Metrics. But now if I retrieve values from originalValues, I get the changed values from this.Metrics. How do I make a copy of the elements of this.Metrics and don't just get the reference of the array?

In case someone stumble here, now there is 'Array.Clone()'. (.net 4.5) — Aelian, Mar 24 '15 at 23:20
@Jeevaka This question is specifically asking about making a _deep_ copy of an array. According to the [MSDN docs](https://msdn.microsoft.com/en-us/library/system.array.clone(v=vs.110).aspx), `Array.Clone()` "Creates a **shallow** copy of the Array." (emphasis added). — jmbpiano, Jul 15 '16 at 17:36
@ jmbpiano: Well, if I am right:, 'int's are stored by value, not by reference. What would happen here is that Array.Clone() would create a new Array object and copy whatever in the memory referenced by 'this.Matrices' reference. Because the contents of the array are not references, the new copy would not share anything with the original. If these were not 'int's but something derived from 'object' your argument would be correct. I guess we can always try and see. — Aelian, Jul 15 '16 at 21:36
Yes, all you need here is a shallow copy. Shallow = 1 data level deep. And that's all you need here since int is immutable. — Nyerguds, Nov 28 '16 at 09:53
@jmbpiano I changed the wording of the question to reflect its spirit. OP was clearly interested in specifically a **shallow copy** but used the wrong term. — Ruzihm, Nov 14 '18 at 19:47

score 31 · Answer 1 · answered Oct 29 '10 at 17:17

31

I don't know where I got this from, but this works well for me.

public static class GenericCopier<T>    //deep copy a list
    {
        public static T DeepCopy(object objectToCopy)
        {
            using (MemoryStream memoryStream = new MemoryStream())
            {
                BinaryFormatter binaryFormatter = new BinaryFormatter();
                binaryFormatter.Serialize(memoryStream, objectToCopy);
                memoryStream.Seek(0, SeekOrigin.Begin);
                return (T)binaryFormatter.Deserialize(memoryStream);
            }
        }
    }

answered Oct 29 '10 at 17:17

Mark W

811
2
11
17

This one is a bit more costly than the Array.Copy answer by Brian Scott – Nicholas Apr 29 '15 at 09:28
8

Calling this an overkill is like calling a supernova "boom" :D – Przemysław Wrzesiński May 11 '15 at 08:49
Another way to clone List is as follows \n var clonedList = new List(sampleList); – Navap Jan 11 '17 at 02:39
This was the best solution for me as I have arrays of nested objects. The nested objects can also have arrays. It should also be mentioned that each object must have the [Serializable] attribute for this to work. – rrirower Sep 13 '17 at 20:47

score 29 · Accepted Answer · answered Oct 29 '10 at 16:51

29

You can clone an array, which makes a copy of it:

int[,] originalValues = (int[,])this.Metrics.Clone();

answered Oct 29 '10 at 16:51

Pieter van Ginkel

29,160
8
71
111

31

Clone does not make a deep copy (except int he trivial cases of value type arrays). – John Nicholas Oct 29 '10 at 16:57
15

Little secret: the question is about an int array. Anything else than this would be quite overkill. – Pieter van Ginkel Oct 29 '10 at 16:59
3

lol, i was just answering the general question. Why ask for a deep copy of a value type? – John Nicholas Oct 29 '10 at 17:01
I think the OP thinks this is an array of arrays, not a multi dimensional array :). – Pieter van Ginkel Oct 29 '10 at 17:02
I dont know but in Java I always called this a 2dimensional array and nobody disagreed ;) Any yes, I need it only for ints. – RoflcoptrException Oct 29 '10 at 17:12
In .NET, this is one data structure. The `Clone()` will be enough. – Pieter van Ginkel Oct 29 '10 at 17:21
Yes thanks. This works fine. I'll accept this answer. Although the other are also great, this is just the simples solution for my problem. Thanks to all! – RoflcoptrException Oct 29 '10 at 21:58
If you're on .Net 3.5, just use Linq's `.ToArray()`. It doesn't need casting, and also creates a copy. – Nyerguds Nov 28 '16 at 09:54

score 11 · Answer 3 · edited May 23 '17 at 11:54

The crux of your problem is here:

There I store this values in another two-dimensional array

This is actually inaccurate. You are not creating a new array; you are setting your originalValues variable to the same array. For a more detailed explanation, see below.

The confusion expressed in the comments to Pieter's answer is due to some uncertainty surrounding the term "deep copy."

When it comes to copying objects, there's deep copying and shallow copying.

Deep copying involves making a copy of all the data belonging to an object, which means that if the object includes members which are themselves complex (for example, instances of user-defined reference types), those objects must be deep-copied as well (along with all of their members, and so on).

Shallow copying involves simply copying all of the fields from one object to another, which means that if the object includes reference types, only the references need to be copied (and so the copied references will be pointing to the same objects).

In the case of the code you've posted:

int[,] originalValues = this.Metrics;

... there's actually no copying of any objects at all. All you've done is copied a single reference, assigning the value of this.Metrics (a reference) to the variable originalValues (also a reference, to the very same array). This is essentially the same as a simple value assignment, like this:

int x = y; // No objects being copied here.

Now, the Array.Clone method makes, in fact, a shallow copy. But as Pieter pointed out, there's really no difference between a "shallow" or "deep" copy of an array of integers, since integers are not complex objects.

If you had something like this:

StringBuilder[,] builders = GetStringBuilders();
StringBuilder[,] builderCopies = (StringBuilder[,])builders.Clone();

..., you'd end up with a whole new array (a copy, yes), but one containing all of the same StringBuilder objects (so a shallow copy). This is where deep versus shallow copying comes into play; if you wanted a new array containing copies of all of the StringBuilder objects from builders, you'd need to make a deep copy.

Well, `int x = y;` does copy _something_; int is immutable and assigning it to a new variable will always create a copy. But yes, that is essentially what happens here, only, the copied value is the _reference_ to the array, not the array itself. — Nyerguds, Nov 28 '16 at 09:57

score 9 · Answer 4 · edited Dec 03 '12 at 17:27

9

If the object you are copying is an array, then you can use:

Array.Copy(sourceArray, destinationArray, sourceArray.Count)

This will give you a separate copy of the original array into your destination array.

edited Dec 03 '12 at 17:27

Peter Mortensen

30,738
21
105
131

answered Oct 29 '10 at 16:55

Brian Scott

9,221
6
47
68

Shouldn't it be `Array.Copy(sourceArray, destinationArray, sourceArray.Count())` or `Array.Copy(sourceArray, destinationArray, sourceArray.Length)`? – FranzHuber23 Feb 15 '23 at 12:49

score 2 · Answer 5 · answered Jun 23 '17 at 22:28

If you want to deep copy an array of reference types, you can do this methodology:

Implement IClonable iterface for your class and do your deep copy of all value typed fields inside to another constructed object.

class A: ICloneable {
     int field1;
     public object Clone()
        {
            A a= new A();
            //copy your fields here 
            a.field1 = this.field1;
            ...
        }
}

Then you can do the actual copy using

A[] array1 = new A[]{....};
A[] array2 = array1.Select(a => a.Clone()).ToList();

score 2 · Answer 6 · edited May 10 '18 at 18:05

IClonable is great but unless you IClonable every type in your top level cloned type, you end up with references, AFAIK.

Based on that, unless you want to walk the object and clone each object within, this seems the simplest approach.

It's simple and guarantees a clean break from references of deep objects in the original:

using Newtonsoft.Json;

private T DeepCopy<T>(object input) where T : class
{
    var copy = JsonConvert.SerializeObject((T)input); // serialise to string json object
    var output = JsonConvert.DeserializeObject<T>(copy); // deserialise back to poco
    return output;
}

Usage:

var x = DeepCopy<{ComplexType}>(itemToBeCloned);

Where ComplexType is anything wanting a break from references.

It takes any Type in, stringifies it, then de-stringifies to a new copy.

Best use example: If you've selected a complex type as a result of a lambda query and want to modify the result without affecting the original.

score 1 · Answer 7 · answered Jan 18 '17 at 15:55

You can deepcopy a 1d array using LINQ.

var array = Enumerable.Range(0, 10).ToArray();
var array2 = array.Select(x => x).ToArray();
array2[0] = 5;
Console.WriteLine(array[0]);  // 0
Console.WriteLine(array2[0]); // 5

With 2d array, this will not work because 2d array doesn't implement IEnumerable.

score 0 · Answer 8 · edited Dec 03 '12 at 17:27

You need to create a new array. You then need to manually copy the value of each element into the new array. What you are doing in the example given is to create two array variables which both reference the same array.

The problem with the clone method is that it is a shallow copy. In this isntance, because you are using int, it does not mater. Howver, if you had an array of classes the definition of the ICLonable interface leaves it ambiguous as to how deep the clone will go.

Imagine if you had a class that has properties that are other classes which has properties that are other classes. The clonable interface does not state whether it will also clone the sub members or not. Moreover, many people have different views on what the expected behaviour is.

Hence this is why it is often recommended to define two interfaces, IShallowCopy and IDeepCopy.

score 0 · Answer 9 · answered Jul 01 '19 at 07:26

Here is a fast solution that is almost similar than some answers here, but which mention MemberwiseClone.

I have POCO classes that only contains reference values.

public class MyPoco {
    public int x { get; set; }
    public int y { get; set; }
    public int z { get; set; }

    // Add a "Clone" method.
    public MyPoco Clone() {
        return (MyPoco)this.MemberwiseClone();
    }
}

Then use LINQ to build a new array of clones:

var myClone = MyPocoArray.Select(x => x.Clone).ToArray();

How to make a shallow copy of an array?

9 Answers9

Linked

Related