Proporciona métodos para la creación, manipulación, búsqueda y ordenación de matrices, por lo tanto, sirve como clase base para todas las matrices de Common Language Runtime.
Espacio de nombres: System
Ensamblado: mscorlib (en mscorlib.dll)
Visual Basic (Declaración)
<SerializableAttribute> _
<ComVisibleAttribute(True)> _
Public MustInherit Class Array
Implements ICloneable, IList, ICollection, IEnumerable
[SerializableAttribute]
[ComVisibleAttribute(true)]
public abstract class Array : ICloneable, IList, ICollection,
IEnumerable
[SerializableAttribute]
[ComVisibleAttribute(true)]
public ref class Array abstract : ICloneable, IList, ICollection,
IEnumerable
/** @attribute SerializableAttribute() */
/** @attribute ComVisibleAttribute(true) */
public abstract class Array implements ICloneable, IList,
ICollection, IEnumerable
SerializableAttribute
ComVisibleAttribute(true)
public abstract class Array implements ICloneable, IList,
ICollection, IEnumerable
La clase Array es la clase base para las implementaciones de lenguajes que admiten matrices. No obstante, el sistema y los compiladores son los únicos que se pueden derivar explícitamente de la clase Array. Los usuarios deben utilizar los constructores de matriz que proporciona el lenguaje.
Un elemento es un valor de Array. La longitud de Array es el número total de elementos que puede contener. El rango de Array es el número de dimensiones de Array. El límite inferior de una dimensión de Array es el índice inicial de dicha dimensión; Array multidimensional Arraypuede tener distintos límites para cada dimensión.
.gif) Importante: |
|---|
| En la versión 2.0 de .NET Framework, la clase Array implementa las interfaces genéricas System.Collections.Generic.IList, System.Collections.Generic.ICollection y System.Collections.Generic.IEnumerable. Las implementaciones se proporcionan a matrices en tiempo de ejecución y por consiguiente no son visibles para las herramientas de generación de documentación. Como consecuencia, las interfaces genéricas no aparecen en la sintaxis de declaración de la clase Array y no existen temas de referencia para los miembros de interfaz a los que sólo se puede obtener acceso convirtiendo una matriz en el tipo de interfaz genérica (implementaciones explícitas de interfaz). Al convertir una matriz en una de esas interfaces, lo principal que se debe tener en cuenta es que los miembros que agregan, insertan o quitan elementos inician una excepción NotSupportedException. |
Los objetos Type proporcionan información sobre las declaraciones de tipo de matriz. Los objetos Array con el mismo tipo de matriz comparten el mismo objeto Type.
Es posible que Type.IsArray y Type.GetElementType no devuelvan el resultado esperado con Array, porque si una matriz se convierte en el tipo Array, el resultado es un objeto y no una matriz. Es decir, typeof(System.Array).IsArray devuelve false y typeof(System.Array).GetElementType devuelve referencia de objeto null (Nothing en Visual Basic).
A diferencia de la mayoría de las clases, Array proporciona el método CreateInstance en lugar de constructores públicos, para permitir el acceso en tiempo de ejecución.
El método Array.Copy copia elementos no sólo entre matrices del mismo tipo, sino también entre matrices estándar de tipos distintos, ya que controla la conversión de tipos de forma automática.
Algunos métodos, como CreateInstance, Copy, CopyTo, GetValue y SetValue, proporcionan sobrecargas que aceptan enteros de 64 bits como parámetros para alojar matrices de gran capacidad. LongLength y GetLongLength devuelven enteros de 64 bits que indican la longitud de la matriz.
No se garantiza que la matriz Array esté ordenada. Debe ordenar la matriz Array antes de realizar operaciones (como BinarySearch) que requieran que la matriz Array esté ordenada.
En el siguiente ejemplo de código se muestra la forma en que el método Array.Copy copia elementos entre una matriz de tipo entero y una matriz de tipo Object.
Public Class SamplesArray
Public Shared Sub Main()
' Creates and initializes a new integer array and a new Object array.
Dim myIntArray() As Integer = {1, 2, 3, 4, 5}
Dim myObjArray() As Object = {26, 27, 28, 29, 30}
' Prints the initial values of both arrays.
Console.WriteLine("Initially,")
Console.Write("integer array:")
PrintValues(myIntArray)
Console.Write("Object array: ")
PrintValues(myObjArray)
' Copies the first two elements from the integer array to the Object array.
Array.Copy(myIntArray, myObjArray, 2)
' Prints the values of the modified arrays.
Console.WriteLine(ControlChars.NewLine + "After copying the first two" _
+ " elements of the integer array to the Object array,")
Console.Write("integer array:")
PrintValues(myIntArray)
Console.Write("Object array: ")
PrintValues(myObjArray)
' Copies the last two elements from the Object array to the integer array.
Array.Copy(myObjArray, myObjArray.GetUpperBound(0) - 1, myIntArray, _
myIntArray.GetUpperBound(0) - 1, 2)
' Prints the values of the modified arrays.
Console.WriteLine(ControlChars.NewLine + "After copying the last two" _
+ " elements of the Object array to the integer array,")
Console.Write("integer array:")
PrintValues(myIntArray)
Console.Write("Object array: ")
PrintValues(myObjArray)
End Sub
Overloads Public Shared Sub PrintValues(myArr() As Object)
Dim i As Object
For Each i In myArr
Console.Write(ControlChars.Tab + "{0}", i)
Next i
Console.WriteLine()
End Sub
Overloads Public Shared Sub PrintValues(myArr() As Integer)
Dim i As Integer
For Each i In myArr
Console.Write(ControlChars.Tab + "{0}", i)
Next i
Console.WriteLine()
End Sub
End Class
' This code produces the following output.
'
' Initially,
' integer array: 1 2 3 4 5
' Object array: 26 27 28 29 30
'
' After copying the first two elements of the integer array to the Object array,
' integer array: 1 2 3 4 5
' Object array: 1 2 28 29 30
'
' After copying the last two elements of the Object array to the integer array,
' integer array: 1 2 3 29 30
' Object array: 1 2 28 29 30
public class SamplesArray {
public static void Main() {
// Creates and initializes a new integer array and a new Object array.
int[] myIntArray = new int[5] { 1, 2, 3, 4, 5 };
Object[] myObjArray = new Object[5] { 26, 27, 28, 29, 30 };
// Prints the initial values of both arrays.
Console.WriteLine( "Initially," );
Console.Write( "integer array:" );
PrintValues( myIntArray );
Console.Write( "Object array: " );
PrintValues( myObjArray );
// Copies the first two elements from the integer array to the Object array.
Array.Copy( myIntArray, myObjArray, 2 );
// Prints the values of the modified arrays.
Console.WriteLine( "\nAfter copying the first two elements of the integer array to the Object array," );
Console.Write( "integer array:" );
PrintValues( myIntArray );
Console.Write( "Object array: " );
PrintValues( myObjArray );
// Copies the last two elements from the Object array to the integer array.
Array.Copy( myObjArray, myObjArray.GetUpperBound(0) - 1, myIntArray, myIntArray.GetUpperBound(0) - 1, 2 );
// Prints the values of the modified arrays.
Console.WriteLine( "\nAfter copying the last two elements of the Object array to the integer array," );
Console.Write( "integer array:" );
PrintValues( myIntArray );
Console.Write( "Object array: " );
PrintValues( myObjArray );
}
public static void PrintValues( Object[] myArr ) {
foreach ( Object i in myArr ) {
Console.Write( "\t{0}", i );
}
Console.WriteLine();
}
public static void PrintValues( int[] myArr ) {
foreach ( int i in myArr ) {
Console.Write( "\t{0}", i );
}
Console.WriteLine();
}
}
/*
This code produces the following output.
Initially,
integer array: 1 2 3 4 5
Object array: 26 27 28 29 30
After copying the first two elements of the integer array to the Object array,
integer array: 1 2 3 4 5
Object array: 1 2 28 29 30
After copying the last two elements of the Object array to the integer array,
integer array: 1 2 3 29 30
Object array: 1 2 28 29 30
*/
using namespace System;
void main1();
void main2();
void main()
{
main1();
Console::WriteLine();
main2();
}
void PrintValues( array<Object^>^myArr );
void PrintValues( array<int>^myArr );
void main1()
{
// Creates and initializes a new int array and a new Object array.
array<int>^myIntArray = {1,2,3,4,5};
array<Object^>^myObjArray = {26,27,28,29,30};
// Prints the initial values of both arrays.
Console::WriteLine( "Initially," );
Console::Write( "int array: " );
PrintValues( myIntArray );
Console::Write( "Object array:" );
PrintValues( myObjArray );
// Copies the first two elements from the int array to the Object array.
Array::Copy( myIntArray, myObjArray, 2 );
// Prints the values of the modified arrays.
Console::WriteLine( "\nAfter copying the first two elements of the int array to the Object array," );
Console::Write( "int array: " );
PrintValues( myIntArray );
Console::Write( "Object array:" );
PrintValues( myObjArray );
// Copies the last two elements from the Object array to the int array.
Array::Copy( myObjArray, myObjArray->GetUpperBound( 0 ) - 1, myIntArray, myIntArray->GetUpperBound( 0 ) - 1, 2 );
// Prints the values of the modified arrays.
Console::WriteLine( "\nAfter copying the last two elements of the Object array to the int array," );
Console::Write( "int array: " );
PrintValues( myIntArray );
Console::Write( "Object array:" );
PrintValues( myObjArray );
}
void PrintValues( array<Object^>^myArr )
{
for ( int i = 0; i < myArr->Length; i++ )
{
Console::Write( "\t{0}", myArr[ i ] );
}
Console::WriteLine();
}
void PrintValues( array<int>^myArr )
{
for ( int i = 0; i < myArr->Length; i++ )
{
Console::Write( "\t{0}", myArr[ i ] );
}
Console::WriteLine();
}
/*
This code produces the following output.
Initially,
int array: 1 2 3 4 5
Object array: 26 27 28 29 30
After copying the first two elements of the int array to the Object array,
int array: 1 2 3 4 5
Object array: 1 2 28 29 30
After copying the last two elements of the Object array to the int array,
int array: 1 2 3 29 30
Object array: 1 2 28 29 30
*/
public class SamplesArray
{
public static void main(String[] args)
{
// Creates and initializes a new integer array and a new Object array.
int myIntArray[] = new int[] { 1, 2, 3, 4, 5 };
Object myObjArray[] = new Object[] { (Int32)26, (Int32)27, (Int32)28,
(Int32)29, (Int32)30};
// Prints the initial values of both arrays.
Console.WriteLine("Initially,");
Console.Write("integer array:");
PrintValues(myIntArray);
Console.Write("Object array: ");
PrintValues(myObjArray);
// Copies the first two elements from the integer array to the
// Object array.
Array.Copy(myIntArray, myObjArray, 2);
// Prints the values of the modified arrays.
Console.WriteLine("\nAfter copying the first two elements of the"
+ " integer array to the Object array,");
Console.Write("integer array:");
PrintValues(myIntArray);
Console.Write("Object array: ");
PrintValues(myObjArray);
// Copies the last two elements from the Object array to the
// integer array.
Array.Copy(myObjArray, myObjArray.GetUpperBound(0) - 1, myIntArray,
myIntArray.GetUpperBound(0) - 1, 2);
// Prints the values of the modified arrays.
Console.WriteLine("\nAfter copying the last two elements of the Object"
+ " array to the integer array,");
Console.Write("integer array:");
PrintValues(myIntArray);
Console.Write("Object array: ");
PrintValues(myObjArray);
} //main
public static void PrintValues(Object myArr[])
{
Object i = null;
for (int iCtr = 0; iCtr < myArr.get_Length(); iCtr++) {
i = myArr[iCtr];
Console.Write("\t{0}", i);
}
Console.WriteLine();
} //PrintValues
public static void PrintValues(int myArr[])
{
int i = 0;
for (int iCtr = 0; iCtr < myArr.get_Length(); iCtr++) {
i = myArr[iCtr];
Console.Write("\t{0}", (Int32)i);
}
Console.WriteLine();
} //PrintValues
} //SamplesArray
/*
This code produces the following output.
Initially,
integer array: 1 2 3 4 5
Object array: 26 27 28 29 30
After copying the first two elements of the integer array to the Object array,
integer array: 1 2 3 4 5
Object array: 1 2 28 29 30
After copying the last two elements of the Object array to the integer array,
integer array: 1 2 3 29 30
Object array: 1 2 28 29 30
*/
En el siguiente ejemplo de código se crea y se inicializa Array, y se muestran sus propiedades y elementos.
Public Class SamplesArray2
Public Shared Sub Main()
' Creates and initializes a new three-dimensional Array of
' type Int32.
Dim myArr As Array = Array.CreateInstance(GetType(Int32), 2, 3, 4)
Dim i As Integer
For i = myArr.GetLowerBound(0) To myArr.GetUpperBound(0)
Dim j As Integer
For j = myArr.GetLowerBound(1) To myArr.GetUpperBound(1)
Dim k As Integer
For k = myArr.GetLowerBound(2) To myArr.GetUpperBound(2)
myArr.SetValue(i * 100 + j * 10 + k, i, j, k)
Next k
Next j
Next i ' Displays the properties of the Array.
Console.WriteLine("The Array has {0} dimension(s) and a " _
+ "total of {1} elements.", myArr.Rank, myArr.Length)
Console.WriteLine(ControlChars.Tab + "Length" + ControlChars.Tab _
+ "Lower" + ControlChars.Tab + "Upper")
For i = 0 To myArr.Rank - 1
Console.Write("{0}:" + ControlChars.Tab + "{1}", i, _
myArr.GetLength(i))
Console.WriteLine(ControlChars.Tab + "{0}" + ControlChars.Tab _
+ "{1}", myArr.GetLowerBound(i), myArr.GetUpperBound(i))
Next i
' Displays the contents of the Array.
Console.WriteLine("The Array contains the following values:")
PrintValues(myArr)
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.
'
' The Array has 3 dimension(s) and a total of 24 elements.
' Length Lower Upper
' 0: 2 0 1
' 1: 3 0 2
' 2: 4 0 3
' The Array contains the following values:
' 0 1 2 3
' 10 11 12 13
' 20 21 22 23
' 100 101 102 103
' 110 111 112 113
' 120 121 122 123
public class SamplesArray2{
public static void Main() {
// Creates and initializes a new three-dimensional Array of type Int32.
Array myArr = Array.CreateInstance( typeof(Int32), 2, 3, 4 );
for ( int i = myArr.GetLowerBound(0); i <= myArr.GetUpperBound(0); i++ )
for ( int j = myArr.GetLowerBound(1); j <= myArr.GetUpperBound(1); j++ )
for ( int k = myArr.GetLowerBound(2); k <= myArr.GetUpperBound(2); k++ ) {
myArr.SetValue( (i*100)+(j*10)+k, i, j, k );
}
// Displays the properties of the Array.
Console.WriteLine( "The Array has {0} dimension(s) and a total of {1} elements.", myArr.Rank, myArr.Length );
Console.WriteLine( "\tLength\tLower\tUpper" );
for ( int i = 0; i < myArr.Rank; i++ ) {
Console.Write( "{0}:\t{1}", i, myArr.GetLength(i) );
Console.WriteLine( "\t{0}\t{1}", myArr.GetLowerBound(i), myArr.GetUpperBound(i) );
}
// Displays the contents of the Array.
Console.WriteLine( "The Array contains the following values:" );
PrintValues( myArr );
}
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.
The Array has 3 dimension(s) and a total of 24 elements.
Length Lower Upper
0: 2 0 1
1: 3 0 2
2: 4 0 3
The Array contains the following values:
0 1 2 3
10 11 12 13
20 21 22 23
100 101 102 103
110 111 112 113
120 121 122 123
*/
void PrintValues( Array^ myArr );
void main2()
{
// Creates and initializes a new three-dimensional Array instance of type Int32.
Array^ myArr = Array::CreateInstance( Int32::typeid, 2, 3, 4 );
for ( int i = myArr->GetLowerBound( 0 ); i <= myArr->GetUpperBound( 0 ); i++ )
{
for ( int j = myArr->GetLowerBound( 1 ); j <= myArr->GetUpperBound( 1 ); j++ )
{
for ( int k = myArr->GetLowerBound( 2 ); k <= myArr->GetUpperBound( 2 ); k++ )
myArr->SetValue( (i * 100) + (j * 10) + k, i, j, k );
}
}
// Displays the properties of the Array.
Console::WriteLine( "The Array instance has {0} dimension(s) and a total of {1} elements.", myArr->Rank, myArr->Length );
Console::WriteLine( "\tLength\tLower\tUpper" );
for ( int i = 0; i < myArr->Rank; i++ )
{
Console::Write( "{0}:\t{1}", i, myArr->GetLength( i ) );
Console::WriteLine( "\t{0}\t{1}", myArr->GetLowerBound( i ), myArr->GetUpperBound( i ) );
}
Console::WriteLine( "The Array instance contains the following values:" );
PrintValues( myArr );
}
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.
The Array instance has 3 dimension(s) and a total of 24 elements.
Length Lower Upper
0: 2 0 1
1: 3 0 2
2: 4 0 3
The Array instance contains the following values:
0 1 2 3
10 11 12 13
20 21 22 23
100 101 102 103
110 111 112 113
120 121 122 123
*/
public class SamplesArray2
{
public static void main(String[] args)
{
// Creates and initializes a new three-dimensional Array of type Int32.
Array myArr = Array.CreateInstance(Int32.class.ToType(), 2, 3, 4);
for (int i = myArr.GetLowerBound(0); i <= myArr.GetUpperBound(0); i++) {
for (int j = myArr.GetLowerBound(1); j <= myArr.GetUpperBound(1);
j++) {
for (int k = myArr.GetLowerBound(2); k <= myArr.
GetUpperBound(2); k++) {
myArr.SetValue((Int32)(i * 100 + j * 10 + k), i, j, k);
}
}
} // Displays the properties of the Array.
Console.WriteLine("The Array has {0} dimension(s) and a total of"
+ " {1} elements.", System.Convert.ToString(myArr.get_Rank()),
System.Convert.ToString(myArr.get_Length()));
Console.WriteLine("\tLength\tLower\tUpper");
for (int i = 0; i < myArr.get_Rank(); i++) {
Console.Write("{0}:\t{1}", System.Convert.ToString(i),
System.Convert.ToString(myArr.GetLength(i)));
Console.WriteLine("\t{0}\t{1}", System.Convert.ToString(myArr.
GetLowerBound(i)), System.Convert.ToString(myArr.
GetUpperBound(i)));
}
// Displays the contents of the Array.
Console.WriteLine("The Array contains the following values:");
PrintValues(myArr);
} //main
public static void PrintValues(Array myArr)
{
System.Collections.IEnumerator myEnumerator = myArr.GetEnumerator();
int i = 0;
int cols = myArr.GetLength(myArr.get_Rank() - 1);
while (myEnumerator.MoveNext()) {
if (i < cols) {
i++;
}
else {
Console.WriteLine();
i = 1;
}
Console.Write("\t{0}", myEnumerator.get_Current());
}
Console.WriteLine();
} //PrintValues
} //SamplesArray2
/*
This code produces the following output.
The Array has 3 dimension(s) and a total of 24 elements.
Length Lower Upper
0: 2 0 1
1: 3 0 2
2: 4 0 3
The Array contains the following values:
0 1 2 3
10 11 12 13
20 21 22 23
100 101 102 103
110 111 112 113
120 121 122 123
*/
System.Object
System.Array
Seguridad para subprocesos
Los miembros estáticos públicos (Shared en Visual Basic) de este tipo son seguros para la ejecución de subprocesos. No se garantiza que los miembros de instancias sean seguros para la ejecución de subprocesos.
Esta implementación no proporciona un contenedor sincronizado (seguro para la ejecución de subprocesos) para Array; no obstante, las clases de .NET Framework basadas en Array proporcionan sus propias versiones sincronizadas de la colección utilizando la propiedad SyncRoot.
Por su naturaleza, la enumeración mediante una colección no es un procedimiento seguro para la ejecución de subprocesos. Incluso cuando una colección está sincronizada, otros subprocesos todavía pueden modificarla, lo que hace que el enumerador produzca una excepción. Con el fin de garantizar la seguridad para la ejecución de subprocesos durante la enumeración, es posible bloquear la colección durante toda la enumeración o detectar las excepciones provocadas por los cambios que efectúen otros subprocesos.
Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium, Windows Mobile para Pocket PC, Windows Mobile para Smartphone, Windows Server 2003, Windows XP Media Center, Windows XP Professional x64, Windows XP SP2, Windows XP Starter Edition
.NET Framework no admite todas las versiones de cada plataforma. Para obtener una lista de las versiones admitidas, vea Requisitos del sistema.
.NET Framework
Compatible con: 2.0, 1.1, 1.0
.NET Compact Framework
Compatible con: 2.0, 1.0