blocks|key|3127664|text|方法返回一个新的数组(浅拷贝)对象，其中包含原始数组中的所有元素。方法将元素复制到另一个现有数组中。两者都执行浅层复制。浅拷贝意味着内容(每个数组元素)包含对与原始数组中的元素相同的对象的引用。深度复制(这两种方法都不会执行)将创建每个元素对象的新实例，从而产生一个不同但相同的对象。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3127665|不同之处在于：|3127666|1-+CopyTo+require+to+have+a+destination+array+when+Clone+return+a+new+array.
2-+CopyTo+let+you+specify+an+index+(if+required)+to+the+destination+array.|code-block|syntax|javascript|3127667|编辑：|3127668|删除错误的示例。|3127669|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

The <a href="http://msdn.microsoft.com/en-us/library/system.array.clone.aspx" rel="noreferrer">Clone()</a> method returns a new array (a shallow copy) object containing all the elements in the original array. The <a href="http://msdn.microsoft.com/en-us/library/system.array.copyto.aspx" rel="noreferrer">CopyTo()</a> method copies the elements into another existing array. Both perform a shallow copy. A shallow copy means the contents (each array element) contains references to the same object as the elements in the original array. A deep copy (which neither of these methods performs) would create a new instance of each element's object, resulting in a different, yet identical object.

So the difference are :

<pre><code>1- CopyTo require to have a destination array when Clone return a new array.
2- CopyTo let you specify an index (if required) to the destination array.
</code></pre>

Edit:

Remove the wrong example.

blocks|key|3972743|text|正如@PatrickDesjardins所说的那样，两者都执行浅层复制(尽管许多被误导的人认为CopyTo做了深层复制)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3972744|但是，CopyTo允许您将一个数组复制到目标数组中的指定索引，从而使其具有更大的灵活性。|3972745|entityMap^0|1B|6|0|3|6|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|P|8|@]|D|@]|E|$]]]|I|$]]

Both perform shallow copies as @PatrickDesjardins said (despite the many misled souls who think that <code>CopyTo</code> does a deep copy).

However, <code>CopyTo</code> allows you to copy one array to a specified index in the destination array, giving it significantly more flexibility.

blocks|key|821084|text|到目前为止还没有提到的另一个区别是|type|unstyled|depth|inlineStyleRanges|entityRanges|data|821085|821086|with+Clone()目标数组尚不需要存在，因为新数组是从头开始创建的。|unordered-list-item|offset|length|style|CODE|821087|with+CopyTo()不仅需要目标数组已经存在，还需要足够大以容纳指定为目标的索引中的源数组中的所有元素。|821088|821089|entityMap^0|0|0|5|7|0|5|8|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|P|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|Q|8|@$F|R|G|S|H|I]]|9|@]|A|$]]|$1|J|3|K|5|E|7|T|8|@$F|U|G|V|H|I]]|9|@]|A|$]]|$1|L|3|-4|5|6|7|W|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|X|8|@]|9|@]|A|$]]]|N|$]]

One other difference not mentioned so far is that

<ul>
<li>with <code>Clone()</code> the destination array need not exist yet since a new one is created from scratch.</li>
<li>with <code>CopyTo()</code> not only does the destination array need to already exist, it needs to be large enough to hold all the elements in the source array from the index you specify as the destination.</li>
</ul>

blocks|key|821097|text|object[]+myarray+=+new+object[]+{+"one",+2,+"three",+4,+"really+big+number",+2324573984927361+};

//create+shallow+copy+by+CopyTo
//You+have+to+instantiate+your+new+array+first
object[]+myarray2+=+new+object[myarray.Length];
//but+then+you+can+specify+how+many+members+of+original+array+you+would+like+to+copy+
myarray.CopyTo(myarray2,+0);

//create+shallow+copy+by+Clone
object[]+myarray1;
//here+you+don't+need+to+instantiate+array,+
//but+all+elements+of+the+original+array+will+be+copied
myarray1+=+myarray.Clone()+as+object[];

//if+not+sure+that+we+create+a+shalow+copy+lets+test+it
myarray[0]+=+0;
Console.WriteLine(myarray[0]);//+print+0
Console.WriteLine(myarray1[0]);//print+"one"
Console.WriteLine(myarray2[0]);//print+"one"|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|821098|the+source|unstyled|offset|length|821099|entityMap|0|LINK|mutability|MUTABLE|url|http://mgznet.com/CopyToVSClone.aspx^0|0|0|A|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|R|8|@]|9|@$G|S|H|T|1|U]]|A|$]]|$1|I|3|-4|5|F|7|V|8|@]|9|@]|A|$]]]|J|$K|$5|L|M|N|A|$O|P]]]]

<pre><code>object[] myarray = new object[] { "one", 2, "three", 4, "really big number", 2324573984927361 };

//create shallow copy by CopyTo
//You have to instantiate your new array first
object[] myarray2 = new object[myarray.Length];
//but then you can specify how many members of original array you would like to copy 
myarray.CopyTo(myarray2, 0);

//create shallow copy by Clone
object[] myarray1;
//here you don't need to instantiate array, 
//but all elements of the original array will be copied
myarray1 = myarray.Clone() as object[];

//if not sure that we create a shalow copy lets test it
myarray[0] = 0;
Console.WriteLine(myarray[0]);// print 0
Console.WriteLine(myarray1[0]);//print "one"
Console.WriteLine(myarray2[0]);//print "one"
</code></pre>

<a href="http://mgznet.com/CopyToVSClone.aspx" rel="noreferrer">the source</a>

blocks|key|816591|text|Clone()仅用于复制数据/数组的结构，它不复制实际数据。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|816592|CopyTo()复制结构和实际数据。|816593|entityMap^0|0|7|0|0|8|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|P|8|@]|D|@]|E|$]]]|I|$]]

<code>Clone()</code> is used to copy only structure of data/array it doesn't copy the actual data.

<code>CopyTo()</code> copies the structure as well as actual data.

blocks|key|5383997|text|CopyTo()和Clone()都进行了浅层复制。Clone()方法克隆原始数组。它返回一个精确的长度数组。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5383998|另一方面，CopyTo()从指定的目标数组索引处开始，将元素从原始数组复制到目标数组。请注意，这会将元素添加到现有的数组中。|5383999|下面的代码将与CopyTo()进行深度复制的发布内容相矛盾：|5384000|public+class+Test
{
public+string+s;
}

//+Write+Main()+method+and+within+it+call+test()

private+void+test()
{
Test[]+array+=+new+Test[1];
array[0]+=+new+Test();
array[0].s+=+"ORIGINAL";

Test[]+copy+=+new+Test[1];
array.CopyTo(copy,+0);

//+Next+line+displays+"ORIGINAL"
MessageBox.Show("array[0].s+=+"+%2B+array[0].s);
copy[0].s+=+"CHANGED";

//+Next+line+displays+"CHANGED",+showing+that
//+changing+the+copy+also+changes+the+original.
MessageBox.Show("array[0].s+=+"+%2B+array[0].s);
}|code-block|syntax|javascript|5384001|让我来解释一下。如果数组的元素是引用类型，则复制(+Clone()和CopyTo())将一直复制到第一级(顶层)。但较低的级别不会被复制。如果我们还需要更低级别的拷贝，我们必须显式地做。这就是为什么在克隆或复制引用类型元素之后，克隆或复制的数组中的每个元素引用的内存位置与原始数组中的相应元素引用的内存位置相同。这清楚地表明，不会为较低级别创建单独的实例。如果是这样，则改变复制或克隆的数组中的任何元素的值在原始数组的相应元素中不起作用。|5384002|我认为我的解释是详尽的，但我找不到其他方法让它变得易懂。|5384003|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|S|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|T|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Both CopyTo() and Clone() make shallow copy. Clone() method makes a clone of the original array. It returns an exact length array.

On the other hand, CopyTo() copies the elements from the original array to the destination array starting at the specified destination array index. Note that, this adds elements to an already existing array.

The following code will contradict the postings saying that CopyTo() makes a deep copy:

<pre><code>public class Test
{
public string s;
}

// Write Main() method and within it call test()

private void test()
{
Test[] array = new Test[1];
array[0] = new Test();
array[0].s = "ORIGINAL";

Test[] copy = new Test[1];
array.CopyTo(copy, 0);

// Next line displays "ORIGINAL"
MessageBox.Show("array[0].s = " + array[0].s);
copy[0].s = "CHANGED";

// Next line displays "CHANGED", showing that
// changing the copy also changes the original.
MessageBox.Show("array[0].s = " + array[0].s);
}
</code></pre>

Let me explain it a bit. If the elements of the array are of reference types, then the copy (both for Clone() and CopyTo()) will be made upto the first(top) level. But the lower level doesn't get copied. If we need copy of lower level also, we have to do it explicitly. That's why after Cloning or Copying of reference type elements, each element in the Cloned or Copied array refers to the same memory location as referred by the corresponding element in the original array. This clearly indicates that no separate instance is created for lower level. And if it were so then changing the value of any element in the Copied or Cloned array would not have effect in the corresponding element of the original array.

I think that my explanation is exhaustive but I found no other way to make it understandable.

blocks|key|5384067|text|Clone()方法没有给出对目标实例的引用，只是给了你一个副本。CopyTo()方法将元素复制到现有实例中。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|5384068|两者都没有给出目标实例的引用，正如许多成员所说的那样，他们在没有引用的情况下提供浅拷贝(幻觉拷贝)，这是关键。|5384069|entityMap^0|0|7|W|8|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]|$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|O|8|@]|D|@]|E|$]]|$1|H|3|-4|5|6|7|P|8|@]|D|@]|E|$]]]|I|$]]

The <code>Clone()</code> method don't give reference to the target instance just give you a copy.
the <code>CopyTo()</code> method copies the elements into an existing instance.

Both don't give the reference of the target instance and as many members says they give shallow copy (illusion copy) without reference this is the key.

blocks|key|821234|text|正如在许多其他答案中所述，这两种方法都执行数组的shallow+copies。但是，仍有一些差异和建议尚未得到解决，并在以下列表中突出显示。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|821235|System.Array.Clone的特性|style|CODE|821236|使用Object.MemberwiseClone;|821237|Requires+4.0进行的|unordered-list-item|BOLD|821238|测试表明，它比.NET+慢，这可能是因为它使用CopyTo将结果数组转换为适当的类型；|821239|结果数组的长度与源数组的长度相同。|821240|821241|821242|System.Array.CopyTo的特性|821243|在将相同type;|821244|It调用的数组复制到object[];|821245|Can时比快继承的是++，这是最有用的：|821246|可以将值型元素装箱为引用类型元素，例如，将int[]数组复制到引用类型元素中，例如，将装箱的<>D40int[]>的object[]数组复制到<代码>D41中；源数组可以对值类型执行扩展转换，例如将int[]复制到long[].|821247|Can+downcast元素中，例如将Stream[]数组复制到MemoryStream[]中(如果源数组中的任何元素不能转换为MemoryStream，则异常为thrown).|821248|821249|821250|​|821251|821252|允许将源拷贝到长度大于源的目标数组。|821253|821254|还要注意，这些方法可用于支持ICloneable和ICollection，因此，如果处理数组类型的变量，则不应使用Clone或CopyTo，而应使用Array.Copy或Array.ConstrainedCopy。受限拷贝可确保如果拷贝操作不能成功完成，则目标阵列状态不会损坏。|821255|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/184710/what-is-the-difference-between-a-deep-copy-and-a-shallow-copy|1|http://msdn.microsoft.com/en-us/library/system.array.clone.aspx|2|http://msdn.microsoft.com/en-us/library/system.object.memberwiseclone.aspx|3|http://msdn.microsoft.com/en-us/library/06x742cw.aspx|4|http://msdn.microsoft.com/en-us/library/system.icloneable.aspx|5|http://msdn.microsoft.com/en-us/library/system.collections.icollection.aspx|6|http://msdn.microsoft.com/en-us/library/k4yx47a1.aspx|7|http://msdn.microsoft.com/en-us/library/system.array.constrainedcopy.aspx^0|O|E|0|0|0|I|0|I|1|0|2|M|2|M|2|0|0|F|0|0|17|N|6|0|0|H|0|0|0|0|M|0|J|0|J|3|0|0|9|0|0|J|A|8|0|0|A|C|8|0|0|V|L|5|1M|8|2R|5|2Z|6|0|J|8|W|E|1S|C|0|0|0|0|0|0|0|E|A|P|B|1L|5|1R|6|22|A|2D|L|E|A|4|P|B|5|22|A|6|2D|L|7|0^^$0|@$1|2|3|4|5|6|7|21|8|@]|9|@$A|22|B|23|1|24]]|C|$]]|$1|D|3|E|5|6|7|25|8|@$A|26|B|27|F|G]]|9|@$A|28|B|29|1|2A]]|C|$]]|$1|H|3|I|5|6|7|2B|8|@$A|2C|B|2D|F|G]]|9|@$A|2E|B|2F|1|2G]]|C|$]]|$1|J|3|K|5|L|7|2H|8|@$A|2I|B|2J|F|M]]|9|@]|C|$]]|$1|N|3|O|5|L|7|2K|8|@$A|2L|B|2M|F|M]|$A|2N|B|2O|F|G]]|9|@]|C|$]]|$1|P|3|Q|5|L|7|2P|8|@$A|2Q|B|2R|F|M]]|9|@]|C|$]]|$1|R|3|-4|5|6|7|2S|8|@]|9|@]|C|$]]|$1|S|3|-4|5|6|7|2T|8|@]|9|@]|C|$]]|$1|T|3|U|5|6|7|2U|8|@$A|2V|B|2W|F|M]|$A|2X|B|2Y|F|G]]|9|@$A|2Z|B|30|1|31]]|C|$]]|$1|V|3|W|5|6|7|32|8|@$A|33|B|34|F|M]]|9|@]|C|$]]|$1|X|3|Y|5|L|7|35|8|@$A|36|B|37|F|M]|$A|38|B|39|F|G]]|9|@]|C|$]]|$1|Z|3|10|5|L|7|3A|8|@$A|3B|B|3C|F|M]|$A|3D|B|3E|F|M]]|9|@]|C|$]]|$1|11|3|12|5|L|7|3F|8|@$A|3G|B|3H|F|M]|$A|3I|B|3J|F|G]|$A|3K|B|3L|F|G]|$A|3M|B|3N|F|G]|$A|3O|B|3P|F|G]]|9|@]|C|$]]|$1|13|3|14|5|L|7|3Q|8|@$A|3R|B|3S|F|G]|$A|3T|B|3U|F|G]|$A|3V|B|3W|F|G]]|9|@]|C|$]]|$1|15|3|-4|5|6|7|3X|8|@]|9|@]|C|$]]|$1|16|3|-4|5|6|7|3Y|8|@]|9|@]|C|$]]|$1|17|3|18|5|6|7|3Z|8|@]|9|@]|C|$]]|$1|19|3|-4|5|6|7|40|8|@]|9|@]|C|$]]|$1|1A|3|1B|5|L|7|41|8|@]|9|@]|C|$]]|$1|1C|3|-4|5|6|7|42|8|@]|9|@]|C|$]]|$1|1D|3|1E|5|6|7|43|8|@$A|44|B|45|F|G]|$A|46|B|47|F|G]|$A|48|B|49|F|G]|$A|4A|B|4B|F|G]|$A|4C|B|4D|F|G]|$A|4E|B|4F|F|G]]|9|@$A|4G|B|4H|1|4I]|$A|4J|B|4K|1|4L]|$A|4M|B|4N|1|4O]|$A|4P|B|4Q|1|4R]]|C|$]]|$1|1F|3|-4|5|6|7|4S|8|@]|9|@]|C|$]]]|1G|$1H|$5|1I|1J|1K|C|$1L|1M]]|1N|$5|1I|1J|1K|C|$1L|1O]]|1P|$5|1I|1J|1K|C|$1L|1Q]]|1R|$5|1I|1J|1K|C|$1L|1S]]|1T|$5|1I|1J|1K|C|$1L|1U]]|1V|$5|1I|1J|1K|C|$1L|1W]]|1X|$5|1I|1J|1K|C|$1L|1Y]]|1Z|$5|1I|1J|1K|C|$1L|20]]]]

As stated in many other answers both methods perform <a href="https://stackoverflow.com/questions/184710/what-is-the-difference-between-a-deep-copy-and-a-shallow-copy">shallow copies</a> of the array. However there are differences and recommendations that have not been addressed yet and that are highlighted in the following lists.

Characteristics of <a href="http://msdn.microsoft.com/en-us/library/system.array.clone.aspx" rel="noreferrer"><code>System.Array.Clone</code></a>:

<ul>
<li>Tests, using .NET 4.0, show that it is slower than <code>CopyTo</code> probably because it uses <a href="http://msdn.microsoft.com/en-us/library/system.object.memberwiseclone.aspx" rel="noreferrer"><code>Object.MemberwiseClone</code></a>;</li>
<li>Requires casting the result to the appropriate type;</li>
<li>The resulting array has the same length as the source.</li>
</ul>

Characteristics of <a href="http://msdn.microsoft.com/en-us/library/06x742cw.aspx" rel="noreferrer"><code>System.Array.CopyTo</code></a>:

<ul>
<li>Is faster than <code>Clone</code> when copying to array of same type;</li>
<li>It calls into <a href="http://msdn.microsoft.com/en-us/library/system.array.constrainedcopy.aspx" rel="noreferrer"><code>Array.Copy</code></a> inheriting is capabilities, being the most useful ones:

<ul>
<li>Can box value type elements into reference type elements, for example, copying an <code>int[]</code> array into an <code>object[]</code>;</li>
<li>Can unbox reference type elements into value type elements, for example, copying a <code>object[]</code> array of boxed <code>int</code> into an <code>int[]</code>;</li>
<li>Can perform widening conversions on value types, for example, copying a <code>int[]</code> into a <code>long[]</code>.</li>
<li>Can downcast elements, for example, copying a <code>Stream[]</code> array into a <code>MemoryStream[]</code> (if any element in source array is not convertible to <code>MemoryStream</code> an exception is thrown).</li>
</ul></li>
<li>Allows to copy the source to a target array that has a length greater than the source.</li>
</ul>

Also note, these methods are made available to support <a href="http://msdn.microsoft.com/en-us/library/system.icloneable.aspx" rel="noreferrer"><code>ICloneable</code></a> and <a href="http://msdn.microsoft.com/en-us/library/system.collections.icollection.aspx" rel="noreferrer"><code>ICollection</code></a>, so if you are dealing with variables of array types you should not use <code>Clone</code> or <code>CopyTo</code> and instead use <a href="http://msdn.microsoft.com/en-us/library/k4yx47a1.aspx" rel="noreferrer"><code>Array.Copy</code></a> or <a href="http://msdn.microsoft.com/en-us/library/system.array.constrainedcopy.aspx" rel="noreferrer"><code>Array.ConstrainedCopy</code></a>. The constrained copy assures that if the copy operation cannot complete successful then the target array state is not corrupted.

blocks|key|816742|text|答案让我很困惑。当您说浅层复制时，这意味着它们仍然指向相同的地址。这意味着，改变其中任何一个也会改变另一个。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|816743|因此，如果我有A=+1,2,3,4，克隆它，得到B=+1,2,3,4。现在，如果我改变B=+9，这意味着A现在将是A=+9,2,3,4，对吗？|816744|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

The answers are confusing to me. When you say shallow copy, this means that they are still pointing to the same address. Which means, changing either one will change another as well. 

So if I have A = [1,2,3,4] and I clone it and get B = [1,2,3,4]. Now, if I change B[0] = 9. This means that A will now be A = [9,2,3,4]. Is that correct?

blocks|key|816772|text|请注意:在StringBuilder[]中使用String[]是有区别的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|816773|在字符串中-如果您更改字符串，我们复制(通过CopyTo或克隆)指向相同字符串的其他数组将不会更改，但原始字符串数组将指向新的字符串，但是，如果我们在数组中使用StringBuilder，字符串指针将不会更改，因此，它将影响我们为此数组所做的所有副本。例如：|816774|public+void+test()
{
++++StringBuilder[]+sArrOr+=+new+StringBuilder[1];
++++sArrOr[0]+=+new+StringBuilder();
++++sArrOr[0].Append("hello");
++++StringBuilder[]+sArrClone+=+(StringBuilder[])sArrOr.Clone();
++++StringBuilder[]+sArrCopyTo+=+new+StringBuilder[1];
++++sArrOr.CopyTo(sArrCopyTo,0);
++++sArrOr[0].Append("+world");

++++Console.WriteLine(sArrOr[0]+%2B+"+"+%2B+sArrClone[0]+%2B+"+"+%2B+sArrCopyTo[0]);
++++//Outputs:+hello+world+hello+world+hello+world

++++//Same+result+in+int[]+as+using+String[]
++++int[]+iArrOr+=+new+int[2];
++++iArrOr[0]+=+0;
++++iArrOr[1]+=+1;
++++int[]+iArrCopyTo+=+new+int[2];
++++iArrOr.CopyTo(iArrCopyTo,0);
++++int[]+iArrClone+=+(int[])iArrOr.Clone();
++++iArrOr[0]%2B%2B;
++++Console.WriteLine(iArrOr[0]+%2B+"+"+%2B+iArrClone[0]+%2B+"+"+%2B+iArrCopyTo[0]);
+++//+Output:+1+0+0
}|code-block|syntax|javascript|816775|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Please note: There is a difference between using String[] to StringBuilder[].

In String - if you change the String, the other arrays we have copied (by CopyTo or Clone) that points to the same string will not change, but the original String array will point to a new String, however, if we use a StringBuilder in an array, the String pointer will not change, therefore, it will affect all the copies we have made for this array. For instance:

<pre><code>public void test()
{
 StringBuilder[] sArrOr = new StringBuilder[1];
 sArrOr[0] = new StringBuilder();
 sArrOr[0].Append("hello");
 StringBuilder[] sArrClone = (StringBuilder[])sArrOr.Clone();
 StringBuilder[] sArrCopyTo = new StringBuilder[1];
 sArrOr.CopyTo(sArrCopyTo,0);
 sArrOr[0].Append(" world");

 Console.WriteLine(sArrOr[0] + " " + sArrClone[0] + " " + sArrCopyTo[0]);
 //Outputs: hello world hello world hello world

 //Same result in int[] as using String[]
 int[] iArrOr = new int[2];
 iArrOr[0] = 0;
 iArrOr[1] = 1;
 int[] iArrCopyTo = new int[2];
 iArrOr.CopyTo(iArrCopyTo,0);
 int[] iArrClone = (int[])iArrOr.Clone();
 iArrOr[0]++;
 Console.WriteLine(iArrOr[0] + " " + iArrClone[0] + " " + iArrCopyTo[0]);
 // Output: 1 0 0
}
</code></pre>

blocks|key|5384353|text|两者都是浅层副本。CopyTo方法不是深度副本。请检查以下代码：|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|5384354|public+class+TestClass1
{
++++public+string+a+=+"test1";
}

public+static+void+ArrayCopyClone()
{
++++TestClass1+tc1+=+new+TestClass1();
++++TestClass1+tc2+=+new+TestClass1();

++++TestClass1[]+arrtest1+=+{+tc1,+tc2+};
++++TestClass1[]+arrtest2+=+new+TestClass1[arrtest1.Length];
++++TestClass1[]+arrtest3+=+new+TestClass1[arrtest1.Length];

++++arrtest1.CopyTo(arrtest2,+0);
++++arrtest3+=+arrtest1.Clone()+as+TestClass1[];

++++Console.WriteLine(arrtest1[0].a);
++++Console.WriteLine(arrtest2[0].a);
++++Console.WriteLine(arrtest3[0].a);

++++arrtest1[0].a+=+"new";

++++Console.WriteLine(arrtest1[0].a);
++++Console.WriteLine(arrtest2[0].a);
++++Console.WriteLine(arrtest3[0].a);
}

/*+Output+is+
test1
test1
test1
new
new
new+*/|code-block|syntax|javascript|5384355|entityMap^0|9|F|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

Both are shallow copies. CopyTo method is not a deep copy.
Check the following code :

<pre><code>public class TestClass1
{
 public string a = "test1";
}

public static void ArrayCopyClone()
{
 TestClass1 tc1 = new TestClass1();
 TestClass1 tc2 = new TestClass1();

 TestClass1[] arrtest1 = { tc1, tc2 };
 TestClass1[] arrtest2 = new TestClass1[arrtest1.Length];
 TestClass1[] arrtest3 = new TestClass1[arrtest1.Length];

 arrtest1.CopyTo(arrtest2, 0);
 arrtest3 = arrtest1.Clone() as TestClass1[];

 Console.WriteLine(arrtest1[0].a);
 Console.WriteLine(arrtest2[0].a);
 Console.WriteLine(arrtest3[0].a);

 arrtest1[0].a = "new";

 Console.WriteLine(arrtest1[0].a);
 Console.WriteLine(arrtest2[0].a);
 Console.WriteLine(arrtest3[0].a);
}

/* Output is 
test1
test1
test1
new
new
new */
</code></pre>

blocks|key|821395|text|Array.Clone在调用函数时不要求目标/目标数组可用，而Array.CopyTo需要目标数组和索引。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|821396|entityMap^0|0|B|V|C|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|M|8|@]|D|@]|E|$]]]|G|$]]

Array.Clone doesn't require a target/destination array to be available when calling the function, whereas Array.CopyTo requires a destination array and an index.

blocks|key|821421|text|当将int或字符串数组作为引用传递给方法时，Array.Clone()将执行技术上的深度复制。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|821422|例如|821423|int[]+numbers+=+new+int[]+{+-11,+12,+-42,+0,+1,+90,+68,+6,+-9+};+

SortByAscending(numbers);+//+Sort+the+array+in+ascending+order+by+clone+the+numbers+array+to+local+new+array.
SortByDescending(numbers);+//+Same+as+Ascending+order+Clone|code-block|syntax|javascript|821424|即使方法对数字数组进行排序，但它不会影响传递给排序方法的实际引用，也就是说，数字数组在第1行中将是相同的未排序的初始格式。|821425|注意：克隆应该在排序方法中完成。|BOLD|821426|entityMap^0|2|3|M|D|0|0|0|0|0|3|0^^$0|@$1|2|3|4|5|6|7|T|8|@$9|U|A|V|B|C]|$9|W|A|X|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Y|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|Z|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|10|8|@]|D|@]|E|$]]|$1|O|3|P|5|6|7|11|8|@$9|12|A|13|B|Q]]|D|@]|E|$]]|$1|R|3|-4|5|6|7|14|8|@]|D|@]|E|$]]]|S|$]]

<code>Array.Clone()</code> would perform technically deep copy, when pass the array of <code>int</code> or string to a method as a reference.
For example
<pre><code>int[] numbers = new int[] { -11, 12, -42, 0, 1, 90, 68, 6, -9 }; 

SortByAscending(numbers); // Sort the array in ascending order by clone the numbers array to local new array.
SortByDescending(numbers); // Same as Ascending order Clone
</code></pre>
Even if the methods sort the array of numbers but it wont affect the actual reference passed to the sorting methods.i.e the number array will be in same unsorted initial format in line no 1.
Note: The Clone should be done in the sorting methods.

What’s the difference between the <code>System.Array.CopyTo()</code> and <code>System.Array.Clone()</code>?

Difference between the System.Array.CopyTo() and System.Array.Clone()

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋 

腾讯云代码助手

CODING DevOps

Cloud Studio

SDK中心

API中心

命令行工具

System.Array.CopyTo()和System.Array.Clone()有什么不同

问System.Array.CopyTo()和System.Array.Clone()之间的区别
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问System.Array.CopyTo()和System.Array.Clone()之间的区别EN