As I said, the documentation for Array.Copy did not have the
answer. It repeatedly says "another array", and leaves out
"same array", which is misleading. It has a lot of text, does
not have either of the key points Fergus found in other pages.
Once again, Fergus, thanks for finding the answer.
*******************************************
.NET Framework Class Library
Array.Copy Method [C#]See Also
Array Class | Array Members | System Namespace | Managed Extensions
for C++ Programming
Language
C#
C++
JScript
Visual Basic
Show All
Copies a section of one Array to another Array and performs type
casting and boxing as required.
Overload List
Copies a range of elements from an Array starting at the first element
and pastes them into another Array starting at the first element. The
length is specified as a 32-bit integer.
[Visual Basic] Overloads Public Shared Sub Copy(Array, Array, Integer)
[C#] public static void Copy(Array, Array, int);
[C++] public: static void Copy(Array*, Array*, int);
[JScript] public static function Copy(Array, Array, int);
Copies a range of elements from an Array starting at the first element
and pastes them into another Array starting at the first element. The
length is specified as a 64-bit integer.
[Visual Basic] Overloads Public Shared Sub Copy(Array, Array, Long)
[C#] public static void Copy(Array, Array, long);
[C++] public: static void Copy(Array*, Array*, __int64);
[JScript] public static function Copy(Array, Array, long);
Copies a range of elements from an Array starting at the specified
source index and pastes them to another Array starting at the
specified destination index. The length and the indexes are specified
as 32-bit integers.
Supported by the .NET Compact Framework.
[Visual Basic] Overloads Public Shared Sub Copy(Array, Integer, Array,
Integer, Integer)
[C#] public static void Copy(Array, int, Array, int, int);
[C++] public: static void Copy(Array*, int, Array*, int, int);
[JScript] public static function Copy(Array, int, Array, int, int);
Copies a range of elements from an Array starting at the specified
source index and pastes them to another Array starting at the
specified destination index. The length and the indexes are specified
as 64-bit integers.
[Visual Basic] Overloads Public Shared Sub Copy(Array, Long, Array,
Long, Long)
[C#] public static void Copy(Array, long, Array, long, long);
[C++] public: static void Copy(Array*, __int64, Array*, __int64,
__int64);
[JScript] public static function Copy(Array, long, Array, long, long);
Example
The following code example shows how to copy from one Array of type
Object to another Array of type integer.
[Visual Basic]
Imports System
Imports Microsoft.VisualBasic
Public Class SamplesArray
Public Shared Sub Main()
' Creates and initializes a new Array of type Int32.
Dim myIntArray As Array = _
Array.CreateInstance(Type.GetType("System.Int32"), 5)
Dim i As Integer
For i = myIntArray.GetLowerBound(0) To
myIntArray.GetUpperBound(0)
myIntArray.SetValue(i + 1, i)
Next i
' Creates and initializes a new Array of type Object.
Dim myObjArray As Array = _
Array.CreateInstance(Type.GetType("System.Object"), 5)
For i = myObjArray.GetLowerBound(0) To
myObjArray.GetUpperBound(0)
myObjArray.SetValue(i + 26, i)
Next i
' Displays the initial values of both arrays.
Console.WriteLine("Int32 array:")
PrintValues(myIntArray)
Console.WriteLine("Object array:")
PrintValues(myObjArray)
' Copies the first element from the Int32 array to the Object
array.
Array.Copy(myIntArray, myIntArray.GetLowerBound(0),
myObjArray, _
myObjArray.GetLowerBound(0), 1)
' Copies the last two elements from the Object array to the
Int32 array.
Array.Copy(myObjArray, myObjArray.GetUpperBound(0) - 1,
myIntArray, _
myIntArray.GetUpperBound(0) - 1, 2)
' Displays the values of the modified arrays.
Console.WriteLine("Int32 array - Last two elements should now
be " _
+ "the same as Object array:")
PrintValues(myIntArray)
Console.WriteLine("Object array - First element should now be
the " _
+ "same as Int32 array:")
PrintValues(myObjArray)
End Sub
Public Shared Sub PrintValues(myArr As Array)
Dim myEnumerator As System.Collections.IEnumerator = _
myArr.GetEnumerator()
Dim i As Integer = 0
Dim cols As Integer = myArr.GetLength((myArr.Rank - 1))
While myEnumerator.MoveNext()
If i < cols Then
i += 1
Else
Console.WriteLine()
i = 1
End If
Console.Write(ControlChars.Tab + "{0}",
myEnumerator.Current)
End While
Console.WriteLine()
End Sub
End Class
' This code produces the following output.
'
' Int32 array:
' 1 2 3 4 5
' Object array:
' 26 27 28 29 30
' Int32 array - Last two elements should now be the same as Object
array:
' 1 2 3 29 30
' Object array - First element should now be the same as Int32 array:
' 1 27 28 29 30
[C#]
using System;
public class SamplesArray {
public static void Main() {
// Creates and initializes a new Array of type Int32.
Array myIntArray=Array.CreateInstance(
Type.GetType("System.Int32"), 5 );
for ( int i = myIntArray.GetLowerBound(0); i <=
myIntArray.GetUpperBound(0); i++ )
myIntArray.SetValue( i+1, i );
// Creates and initializes a new Array of type Object.
Array myObjArray = Array.CreateInstance(
Type.GetType("System.Object"), 5 );
for ( int i = myObjArray.GetLowerBound(0); i <=
myObjArray.GetUpperBound(0); i++ )
myObjArray.SetValue( i+26, i );
// Displays the initial values of both arrays.
Console.WriteLine( "Int32 array:" );
PrintValues( myIntArray );
Console.WriteLine( "Object array:" );
PrintValues( myObjArray );
// Copies the first element from the Int32 array to the Object
array.
Array.Copy( myIntArray, myIntArray.GetLowerBound(0), myObjArray,
myObjArray.GetLowerBound(0), 1 );
// Copies the last two elements from the Object array to the
Int32 array.
Array.Copy( myObjArray, myObjArray.GetUpperBound(0) - 1,
myIntArray, myIntArray.GetUpperBound(0) - 1, 2 );
// Displays the values of the modified arrays.
Console.WriteLine( "Int32 array - Last two elements should now
be the same as Object array:" );
PrintValues( myIntArray );
Console.WriteLine( "Object array - First element should now be
the same as Int32 array:" );
PrintValues( myObjArray );
}
public static void PrintValues( Array myArr ) {
System.Collections.IEnumerator myEnumerator =
myArr.GetEnumerator();
int i = 0;
int cols = myArr.GetLength( myArr.Rank - 1 );
while ( myEnumerator.MoveNext() ) {
if ( i < cols ) {
i++;
} else {
Console.WriteLine();
i = 1;
}
Console.Write( "\t{0}", myEnumerator.Current );
}
Console.WriteLine();
}
}
/*
This code produces the following output.
Int32 array:
1 2 3 4 5
Object array:
26 27 28 29 30
Int32 array - Last two elements should now be the same as Object
array:
1 2 3 29 30
Object array - First element should now be the same as Int32 array:
1 27 28 29 30
*/
[C++]
#using <mscorlib.dll>
using namespace System;
void PrintValues( Array* myArr );
void main() {
// Creates and initializes a new Array instance of type Int32.
Array* myIntArray=Array::CreateInstance(
Type::GetType("System.Int32"), 5 );
for ( int i = myIntArray->GetLowerBound(0); i <=
myIntArray->GetUpperBound(0); i++ )
myIntArray->SetValue( __box(i+1), i );
// Creates and initializes a new Array instance of type Object.
Array* myObjArray = Array::CreateInstance(
Type::GetType("System.Object"), 5 );
for ( int i = myObjArray->GetLowerBound(0); i <=
myObjArray->GetUpperBound(0); i++ )
myObjArray->SetValue( __box(i+26), i );
// Displays the initial values of both arrays.
Console::WriteLine( "Int32 array:" );
PrintValues( myIntArray );
Console::WriteLine( "Object array:" );
PrintValues( myObjArray );
// Copies the first element from the Int32 array to the Object
array.
Array::Copy( myIntArray, myIntArray->GetLowerBound(0),
myObjArray, myObjArray->GetLowerBound(0), 1 );
// Copies the last two elements from the Object array to the
Int32 array.
Array::Copy( myObjArray, myObjArray->GetUpperBound(0) - 1,
myIntArray, myIntArray->GetUpperBound(0) - 1, 2 );
// Displays the values of the modified arrays.
Console::WriteLine( "Int32 array - Last two elements should now
be the same as Object array:" );
PrintValues( myIntArray );
Console::WriteLine( "Object array - First element should now be
the same as Int32 array:" );
PrintValues( myObjArray );
}
void PrintValues( Array* myArr ) {
System::Collections::IEnumerator* myEnumerator =
myArr->GetEnumerator();
int i = 0;
int cols = myArr->GetLength( myArr->Rank - 1 );
while ( myEnumerator->MoveNext() ) {
if ( i < cols ) {
i++;
}
else {
Console::WriteLine();
i = 1;
}
Console::Write( "\t{0}", myEnumerator->Current );
}
Console::WriteLine();
}
/*
This code produces the following output.
Int32 array:
1 2 3 4 5
Object array:
26 27 28 29 30
Int32 array - Last two elements should now be the same as Object
array:
1 2 3 29 30
Object array - First element should now be the same as Int32 array:
1 27 28 29 30
*/
[JScript]
import System;
// Creates and initializes a new System.Array of type Int32.
var myIntArray : System.Array = System.Array.CreateInstance(
Type.GetType("System.Int32"), 5 );
for ( var i : int = myIntArray.GetLowerBound(0); i <=
myIntArray.GetUpperBound(0); i++ )
myIntArray.SetValue( Int32(i+1), i );
// Creates and initializes a new Array of type Object.
var myObjArray : System.Array = System.Array.CreateInstance(
Type.GetType("System.Object"), 5 );
for ( var j : int = myObjArray.GetLowerBound(0); j <=
myObjArray.GetUpperBound(0); j++ )
myObjArray.SetValue( Int32(j+26), j);
// Displays the initial values of both arrays.
Console.WriteLine( "Int32 array:" );
PrintValues( myIntArray );
Console.WriteLine( "Object array:" );
PrintValues( myObjArray );
// Copies the first element from the Int32 array to the Object array.
System.Array.Copy( myIntArray, myIntArray.GetLowerBound(0),
myObjArray, myObjArray.GetLowerBound(0), 1 );
// Copies the last two elements from the Object array to the Int32
array.
System.Array.Copy( myObjArray, myObjArray.GetUpperBound(0) - 1,
myIntArray, myIntArray.GetUpperBound(0) - 1, 2 );
// Displays the values of the modified arrays.
Console.WriteLine( "Int32 array - Last two elements should now be the
same as Object array:" );
PrintValues( myIntArray );
Console.WriteLine( "Object array - First element should now be the
same as Int32 array:" );
PrintValues( myObjArray );
function PrintValues( myArr : System.Array ) {
var myEnumerator : System.Collections.IEnumerator =
myArr.GetEnumerator();
var i : int = 0;
var cols : int = myArr.GetLength( myArr.Rank - 1 );
while ( myEnumerator.MoveNext() ) {
if ( i < cols ) {
i++;
} else {
Console.WriteLine();
i = 1;
}
Console.Write( "\t{0}", myEnumerator.Current );
}
Console.WriteLine();
}
/*
This code produces the following output.
Int32 array:
1 2 3 4 5
Object array:
26 27 28 29 30
Int32 array - Last two elements should now be the same as Object
array:
1 2 3 29 30
Object array - First element should now be the same as Int32 array:
1 27 28 29 30
*/
See Also
Array Class | Array Members | System Namespace | Managed Extensions
for C++ Programming
Syntax based on .NET Framework version 1.1.4322.
November 15, 2002.
--------------------------------------------------------------------------------
Send comments on this topic.
© 2001-2002 Microsoft Corporation. All rights reserved.
Jon Skeet <(E-Mail Removed)> wrote in message news:<(E-Mail Removed)>...
> Fergus Cooney <(E-Mail Removed)> wrote:
> > We're talking that strictly?
> >
> > The info for C# doesn't have it, but the info for C++ does.
>
> The info for C# *does* say what happens when the arrays overlap. I've
> got it right here in front of me, with the C# filter applied:
>
> <quote>
> If sourceArray and destinationArray overlap, this method behaves as if
> the original values of sourceArray were preserved in a temporary
> location before destinationArray is overwritten.
> </quote>
>
> That's looking on the form which takes (Array, Array, Int32) as its
> parameters. It's the third paragraph in the remarks.
>
> There's no need to switch to the C++ filter in order to understand what
> the semantics are.
Similar Threads
