Array Clase
Definición
Importante
Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.
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.
public ref class Array abstract : System::Collections::IList, System::Collections::IStructuralComparable, System::Collections::IStructuralEquatablepublic ref class Array abstract : ICloneable, System::Collections::IList, System::Collections::IStructuralComparable, System::Collections::IStructuralEquatablepublic ref class Array abstract : ICloneable, System::Collections::IListpublic abstract class Array : System.Collections.IList, System.Collections.IStructuralComparable, System.Collections.IStructuralEquatablepublic abstract class Array : ICloneable, System.Collections.IList, System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable[System.Serializable]
public abstract class Array : ICloneable, System.Collections.IList[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public abstract class Array : ICloneable, System.Collections.IList[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public abstract class Array : ICloneable, System.Collections.IList, System.Collections.IStructuralComparable, System.Collections.IStructuralEquatabletype Array = class
interface ICollection
interface IEnumerable
interface IList
interface IStructuralComparable
interface IStructuralEquatabletype Array = class
interface ICollection
interface IEnumerable
interface IList
interface IStructuralComparable
interface IStructuralEquatable
interface ICloneable[<System.Serializable>]
type Array = class
interface ICloneable
interface IList
interface ICollection
interface IEnumerable[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type Array = class
interface ICloneable
interface IList
interface ICollection
interface IEnumerable[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type Array = class
interface ICloneable
interface IList
interface ICollection
interface IEnumerable
interface IStructuralComparable
interface IStructuralEquatabletype Array = class
interface IList
interface ICollection
interface IEnumerable
interface IStructuralComparable
interface IStructuralEquatable[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type Array = class
interface ICloneable
interface ICollection
interface IList
interface IEnumerable
interface IStructuralComparable
interface IStructuralEquatablePublic MustInherit Class Array
Implements IList, IStructuralComparable, IStructuralEquatablePublic MustInherit Class Array
Implements ICloneable, IList, IStructuralComparable, IStructuralEquatablePublic MustInherit Class Array
Implements ICloneable, IList- Herencia
-
Array
- Atributos
- Implementaciones
Ejemplos
En el ejemplo de código siguiente se muestra cómo Array.Copy copia los elementos entre una matriz de tipo entero y una matriz de tipo Object.
using namespace System;
void PrintValues(array<Object^>^myArr);
void PrintValues(array<int>^myArr);
void main()
{
// 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.
System::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.
System::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
*/
open System
let printValues myArr =
for i in myArr do
printf $"\t{i}"
printfn ""
// Creates and initializes a new integer array and a new Object array.
let myIntArray = [| 1..5 |]
let myObjArray = [| 26..30 |]
// Prints the initial values of both arrays.
printfn "Initially,"
printf "integer array:"
printValues myIntArray
printfn "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.
printfn "\nAfter copying the first two elements of the integer array to the Object array,"
printf "integer array:"
printValues myIntArray
printf"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.
printfn $"\nAfter copying the last two elements of the Object array to the integer array,"
printf "integer array:"
printValues myIntArray
printf "Object array: "
printValues myObjArray
// 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 System;
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.
System.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.
System.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
*/
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.
System.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.
System.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
Public Overloads 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
Public Overloads 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
En el ejemplo de código siguiente se crea e inicializa y Array se muestran sus propiedades y sus elementos.
using namespace System;
void PrintValues(Array^ myArr);
void main()
{
// 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
*/
open System
let printValues (myArray: Array) =
let mutable i = 0
let cols = myArray.GetLength(myArray.Rank - 1)
for item in myArray do
if i < cols then
i <- i + 1
else
printfn ""
i <- 1;
printf $"\t{item}"
printfn ""
// Creates and initializes a new three-dimensional Array of type int.
let myArr = Array.CreateInstance(typeof<int>, 2, 3, 4)
for i = myArr.GetLowerBound 0 to myArr.GetUpperBound 0 do
for j = myArr.GetLowerBound 1 to myArr.GetUpperBound 1 do
for k = myArr.GetLowerBound 2 to myArr.GetUpperBound 2 do
myArr.SetValue(i * 100 + j * 10 + k, i, j, k)
// Displays the properties of the Array.
printfn $"The Array has {myArr.Rank} dimension(s) and a total of {myArr.Length} elements."
printfn $"\tLength\tLower\tUpper"
for i = 0 to myArr.Rank - 1 do
printf $"{i}:\t{myArr.GetLength i}"
printfn $"\t{myArr.GetLowerBound i}\t{myArr.GetUpperBound i}"
// Displays the contents of the Array.
printfn "The Array contains the following values:"
printValues myArr
// 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
// Creates and initializes a new three-dimensional Array of type int.
Array myArr = Array.CreateInstance(typeof(int), 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);
void PrintValues(Array myArray)
{
System.Collections.IEnumerator myEnumerator = myArray.GetEnumerator();
int i = 0;
int cols = myArray.GetLength(myArray.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
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
Comentarios
La Array clase no forma parte de los System.Collections espacios de nombres. Sin embargo, todavía se considera una colección porque se basa en la IList interfaz .
La Array clase es la clase base para las implementaciones de lenguaje que admiten matrices. Sin embargo, solo el sistema y los compiladores pueden derivar explícitamente de la Array clase . Los usuarios deben emplear las construcciones de matriz proporcionadas por el lenguaje .
Un elemento es un valor de .Array La longitud de es Array el número total de elementos que puede contener. El límite inferior de un Array es el índice de su primer elemento. Un Array puede tener cualquier límite inferior, pero tiene un límite inferior de cero de forma predeterminada. Se puede definir un límite inferior diferente al crear una instancia de la Array clase mediante CreateInstance. Un multidimensional Array puede tener límites diferentes para cada dimensión. Una matriz puede tener un máximo de 32 dimensiones.
A diferencia de las clases de los System.Collections espacios de nombres, Array tiene una capacidad fija. Para aumentar la capacidad, debe crear un nuevo Array objeto con la capacidad necesaria, copiar los elementos del objeto antiguo Array al nuevo y eliminar el antiguo Array.
El tamaño de la matriz se limita a un total de 4 mil millones de elementos y a un índice máximo de 0X7FEFFFFF en cualquier dimensión determinada (0X7FFFFFC7 para matrices de bytes y matrices de estructuras de un solo byte).
Solo .NET Framework: De forma predeterminada, el tamaño máximo de un Array es de 2 gigabytes (GB). En un entorno de 64 bits, puede evitar la restricción de tamaño estableciendo el enabled atributo del elemento true de configuración gcAllowVeryLargeObjects en en el entorno en tiempo de ejecución.
Las matrices unidimensionales implementan las System.Collections.Generic.IList<T>interfaces genéricas , System.Collections.Generic.ICollection<T>, System.Collections.Generic.IEnumerable<T>System.Collections.Generic.IReadOnlyList<T> y System.Collections.Generic.IReadOnlyCollection<T> . Las implementaciones se proporcionan a matrices en tiempo de ejecución y, como resultado, las interfaces genéricas no aparecen en la sintaxis de declaración de la Array clase . Además, no hay temas de referencia para los miembros de interfaz a los que solo se puede acceder mediante la conversión de una matriz al tipo de interfaz genérico (implementaciones de interfaz explícitas). Lo clave que hay que tener en cuenta al convertir una matriz en una de estas interfaces es que los miembros que agregan, insertan o quitan elementos inician NotSupportedException.
Type Los objetos proporcionan información sobre las declaraciones de tipo de matriz. Array los objetos con el mismo tipo de matriz comparten el mismo Type objeto.
Type.IsArray y Type.GetElementType podrían no devolver los resultados esperados con Array porque si una matriz se convierte en el tipo Array, el resultado es un objeto, no una matriz. Es decir, typeof(System.Array).IsArray devuelve falsey typeof(System.Array).GetElementType devuelve null.
El Array.Copy método copia elementos no solo entre matrices del mismo tipo, sino también entre matrices estándar de diferentes tipos; controla la conversión de tipos automáticamente.
Algunos métodos, como CreateInstance, Copy, CopyTo, GetValuey SetValue, proporcionan sobrecargas que aceptan enteros de 64 bits como parámetros para dar cabida a matrices de gran capacidad. LongLength y GetLongLength devuelven enteros de 64 bits que indican la longitud de la matriz.
Array No se garantiza que se ordene. Debe ordenar antes Array de realizar operaciones (como BinarySearch) que requieren que Array se ordene .
No se admite el uso de un Array objeto de punteros en código nativo y generará un NotSupportedException para varios métodos.
Propiedades
| IsFixedSize |
Obtiene un valor que indica si la interfaz Array tiene un tamaño fijo. |
| IsReadOnly |
Obtiene un valor que indica si Array es de solo lectura. |
| IsSynchronized |
Obtiene un valor que indica si el acceso a la interfaz Array está sincronizado (es seguro para subprocesos). |
| Length |
Obtiene el número total de elementos de todas las dimensiones de Array. |
| LongLength |
Obtiene un entero de 64 bits que representa el número total de elementos de todas las dimensiones de Array. |
| MaxLength |
Obtiene el número máximo de elementos que se pueden contener en una matriz. |
| Rank |
Obtiene el rango (número de dimensiones) de Array. Por ejemplo, una matriz unidimensional devuelve 1, una matriz bidimensional devuelve 2, y así sucesivamente. |
| SyncRoot |
Obtiene un objeto que se puede usar para sincronizar el acceso a Array. |
Métodos
| AsReadOnly<T>(T[]) |
Devuelve un contenedor de solo lectura para la matriz especificada. |
| BinarySearch(Array, Int32, Int32, Object) |
Busca un valor en un intervalo de elementos de una matriz unidimensional y ordenada, usando la interfaz IComparable implementada por cada elemento de la matriz y por el valor especificado. |
| BinarySearch(Array, Int32, Int32, Object, IComparer) |
Busca un valor en un intervalo de elementos de una matriz unidimensional y ordenada, usando la interfaz IComparer especificada. |
| BinarySearch(Array, Object) |
Busca un elemento específico en toda una matriz unidimensional y ordenada, usando la interfaz IComparable implementada por cada elemento de la matriz y por el objeto especificado. |
| BinarySearch(Array, Object, IComparer) |
Busca un valor por toda una matriz unidimensional y ordenada, usando la interfaz IComparer especificada. |
| BinarySearch<T>(T[], Int32, Int32, T) |
Busca un valor en un intervalo de elementos de una matriz unidimensional y ordenada, usando la interfaz genérica IComparable<T> que implementan cada elemento de Array y el valor especificado. |
| BinarySearch<T>(T[], Int32, Int32, T, IComparer<T>) |
Busca un valor en un intervalo de elementos de una matriz unidimensional y ordenada, usando la interfaz genérica IComparer<T> especificada. |
| BinarySearch<T>(T[], T) |
Busca un elemento específico en una matriz unidimensional ordenada completa, usando la interfaz genérica IComparable<T> que implementan cada elemento de Array y el objeto especificado. |
| BinarySearch<T>(T[], T, IComparer<T>) |
Busca un valor por toda una matriz unidimensional y ordenada, usando la interfaz genérica IComparer<T> especificada. |
| Clear(Array) |
Borra el contenido de una matriz. |
| Clear(Array, Int32, Int32) |
Establece un intervalo de elementos de una matriz en el valor predeterminado de cada tipo de elemento. |
| Clone() |
Crea una copia superficial de la colección Array. |
| ConstrainedCopy(Array, Int32, Array, Int32, Int32) |
Copia un intervalo de elementos de un objeto Array a partir del índice de origen especificado y los pega en otro objeto Array a partir del índice de destino especificado. Garantiza que se deshacen todos los cambios si la copia no se realiza de forma totalmente correcta. |
| ConvertAll<TInput,TOutput>(TInput[], Converter<TInput,TOutput>) |
Convierte una matriz de un tipo en una matriz de otro tipo. |
| Copy(Array, Array, Int32) |
Copia un intervalo de elementos de una matriz Array comenzando en el primer elemento y los pega en otra matriz Array comenzando en el primer elemento. La longitud se especifica como un entero de 32 bits. |
| Copy(Array, Array, Int64) |
Copia un intervalo de elementos de una matriz Array comenzando en el primer elemento y los pega en otra matriz Array comenzando en el primer elemento. La longitud se especifica como un entero de 64 bits. |
| Copy(Array, Int32, Array, Int32, Int32) |
Copia un intervalo de elementos de un objeto Array a partir del índice de origen especificado y los pega en otro objeto Array a partir del índice de destino especificado. La longitud y los índices se especifican como enteros de 32 bits. |
| Copy(Array, Int64, Array, Int64, Int64) |
Copia un intervalo de elementos de un objeto Array a partir del índice de origen especificado y los pega en otro objeto Array a partir del índice de destino especificado. La longitud y los índices se especifican como enteros de 64 bits. |
| CopyTo(Array, Int32) |
Copia todos los elementos de la matriz unidimensional actual en la matriz unidimensional especificada, empezando en el índice especificado de la matriz de destino. El índice se especifica como un entero de 32 bits. |
| CopyTo(Array, Int64) |
Copia todos los elementos de la matriz unidimensional actual en la matriz unidimensional especificada, empezando en el índice especificado de la matriz de destino. El índice se especifica como un entero de 64 bits. |
| CreateInstance(Type, Int32) |
Crea una matriz Array unidimensional de la longitud y el Type especificados, con una indización de base cero. |
| CreateInstance(Type, Int32, Int32) |
Crea una matriz Array bidimensional de las longitudes de dimensión y el Type especificados, con una indización de base cero. |
| CreateInstance(Type, Int32, Int32, Int32) |
Crea una Array tridimensional de las longitudes de dimensión y el Type especificados, con una indización de base cero. |
| CreateInstance(Type, Int32[]) |
Crea una Array multidimensional de las longitudes de dimensión y el tipo Type especificados, con una indización de base cero. Las longitudes de dimensión se especifican en una matriz de enteros de 32 bits. |
| CreateInstance(Type, Int32[], Int32[]) |
Crea una matriz Array multidimensional de las longitudes de dimensión y el tipo Type especificados, con los límites inferiores especificados. |
| CreateInstance(Type, Int64[]) |
Crea una Array multidimensional de las longitudes de dimensión y el tipo Type especificados, con una indización de base cero. Las longitudes de dimensión se especifican en una matriz de enteros de 64 bits. |
| Empty<T>() |
Devuelve una matriz vacía. |
| Equals(Object) |
Determina si el objeto especificado es igual que el objeto actual. (Heredado de Object) |
| Exists<T>(T[], Predicate<T>) |
Determina si la matriz especificada contiene elementos que coinciden con las condiciones definidas por el predicado especificado. |
| Fill<T>(T[], T) |
Asigna el objeto |
| Fill<T>(T[], T, Int32, Int32) |
Asigna el objeto |
| Find<T>(T[], Predicate<T>) |
Busca un elemento que coincida con las condiciones definidas por el predicado especificado y devuelve la primera aparición en toda la matriz Array. |
| FindAll<T>(T[], Predicate<T>) |
Recupera todos los elementos que coinciden con las condiciones definidas por el predicado especificado. |
| FindIndex<T>(T[], Int32, Int32, Predicate<T>) |
Busca un elemento que coincida con las condiciones definidas por el predicado especificado y devuelve el índice de base cero de la primera aparición en el intervalo de elementos de la matriz Array que comienza en el índice especificado y contiene el número especificado de elementos. |
| FindIndex<T>(T[], Int32, Predicate<T>) |
Busca un elemento que coincida con las condiciones definidas por el predicado especificado y devuelve el índice de base cero de la primera aparición en el intervalo de elementos de la matriz Array que va desde el índice especificado hasta el último elemento. |
| FindIndex<T>(T[], Predicate<T>) |
Busca un elemento que coincida con las condiciones definidas por el predicado especificado y devuelve el índice de base cero de la primera aparición en toda la matriz Array. |
| FindLast<T>(T[], Predicate<T>) |
Busca un elemento que coincida con las condiciones definidas por el predicado especificado y devuelve la última aparición en toda la matriz Array. |
| FindLastIndex<T>(T[], Int32, Int32, Predicate<T>) |
Busca un elemento que coincida con las condiciones definidas por el predicado especificado y devuelve el índice de base cero de la última aparición en el intervalo de elementos de la matriz Array que contiene el número especificado de elementos y termina en el índice especificado. |
| FindLastIndex<T>(T[], Int32, Predicate<T>) |
Busca un elemento que coincida con las condiciones definidas por el predicado especificado y devuelve el índice de base cero de la última aparición en el intervalo de elementos de la matriz Array que va desde el primer elemento hasta el índice especificado. |
| FindLastIndex<T>(T[], Predicate<T>) |
Busca un elemento que coincida con las condiciones definidas por el predicado especificado y devuelve el índice de base cero de la última aparición en toda la matriz Array. |
| ForEach<T>(T[], Action<T>) |
Realiza la acción especificada en cada elemento de la matriz especificada. |
| GetEnumerator() |
Devuelve una interfaz IEnumerator para la interfaz Array. |
| GetHashCode() |
Sirve como la función hash predeterminada. (Heredado de Object) |
| GetLength(Int32) |
Obtiene un entero de 32 bits que representa el número de elementos de la dimensión especificada de Array. |
| GetLongLength(Int32) |
Obtiene un entero de 64 bits que representa el número de elementos de la dimensión especificada de Array. |
| GetLowerBound(Int32) |
Obtiene el índice del primer elemento de la dimensión especificada en la matriz. |
| GetType() |
Obtiene el Type de la instancia actual. (Heredado de Object) |
| GetUpperBound(Int32) |
Obtiene el índice del último elemento de la dimensión especificada en la matriz. |
| GetValue(Int32) |
Obtiene el valor de la posición especificada de la matriz Array unidimensional. El índice se especifica como un entero de 32 bits. |
| GetValue(Int32, Int32) |
Obtiene el valor de la posición especificada de la Array bidimensional. Los índices se especifican como enteros de 32 bits. |
| GetValue(Int32, Int32, Int32) |
Obtiene el valor de la posición especificada de la Array tridimensional. Los índices se especifican como enteros de 32 bits. |
| GetValue(Int32[]) |
Obtiene el valor de la posición especificada de Array multidimensional. Los índices se especifican en forma de una matriz de enteros de 32 bits. |
| GetValue(Int64) |
Obtiene el valor de la posición especificada de la matriz Array unidimensional. El índice se especifica como un entero de 64 bits. |
| GetValue(Int64, Int64) |
Obtiene el valor de la posición especificada de la Array bidimensional. Los índices se especifican como enteros de 64 bits. |
| GetValue(Int64, Int64, Int64) |
Obtiene el valor de la posición especificada de la Array tridimensional. Los índices se especifican como enteros de 64 bits. |
| GetValue(Int64[]) |
Obtiene el valor de la posición especificada de Array multidimensional. Los índices se especifican como matriz de enteros de 64 bits. |
| IndexOf(Array, Object) |
Busca el objeto especificado y devuelve el índice de su primera aparición en una matriz unidimensional. |
| IndexOf(Array, Object, Int32) |
Busca el objeto especificado en un intervalo de elementos de una matriz unidimensional y devuelve el índice de su primera aparición. El intervalo abarca desde un índice especificado hasta el final de la matriz. |
| IndexOf(Array, Object, Int32, Int32) |
Busca el objeto especificado en un intervalo de elementos de una matriz unidimensional y devuelve el índice de su primera aparición. El intervalo se extiende desde un índice especificado durante un número especificado de elementos. |
| IndexOf<T>(T[], T) |
Busca el objeto especificado y devuelve el índice de su primera aparición en una matriz unidimensional. |
| IndexOf<T>(T[], T, Int32) |
Busca el objeto especificado en un intervalo de elementos de una matriz unidimensional y devuelve el índice de su primera aparición. El intervalo abarca desde un índice especificado hasta el final de la matriz. |
| IndexOf<T>(T[], T, Int32, Int32) |
Busca el objeto especificado en un intervalo de elementos de una matriz unidimensional y devuelve el índice de su primera aparición. El intervalo se extiende desde un índice especificado durante un número especificado de elementos. |
| Initialize() |
Inicializa todos los elementos de la matriz Array de tipo de valor llamando al constructor sin parámetros del tipo de valor. |
| LastIndexOf(Array, Object) |
Busca el objeto especificado y devuelve el índice de la última aparición en toda la matriz Array unidimensional. |
| LastIndexOf(Array, Object, Int32) |
Busca el objeto especificado y devuelve el índice de la última aparición en el intervalo de elementos de la matriz Array unidimensional que se extiende desde el primer elemento hasta el índice especificado. |
| LastIndexOf(Array, Object, Int32, Int32) |
Busca el objeto especificado y devuelve el índice de la última aparición dentro del intervalo de elementos de la Array unidimensional que contiene el número especificado de elementos y termina en el índice especificado. |
| LastIndexOf<T>(T[], T) |
Busca el objeto especificado y devuelve el índice de la última aparición de toda la Array. |
| LastIndexOf<T>(T[], T, Int32) |
Busca el objeto especificado y devuelve el índice de la última aparición en el intervalo de elementos de la Array que se extiende desde el primer elemento hasta el índice especificado. |
| LastIndexOf<T>(T[], T, Int32, Int32) |
Busca el objeto especificado y devuelve el índice de la última aparición en el intervalo de elementos de la Array que contiene el número de elementos especificado y termina en el índice especificado. |
| MemberwiseClone() |
Crea una copia superficial del Object actual. (Heredado de Object) |
| Resize<T>(T[], Int32) |
Cambia el número de elementos de una matriz unidimensional al nuevo tamaño especificado. |
| Reverse(Array) |
Invierte la secuencia de los elementos de toda la matriz Array unidimensional. |
| Reverse(Array, Int32, Int32) |
Invierte la secuencia de un subconjunto de los elementos de la matriz Array unidimensional. |
| Reverse<T>(T[]) |
Invierte la secuencia de los elementos de la matriz genérica unidimensional. |
| Reverse<T>(T[], Int32, Int32) |
Invierte la secuencia de un subconjunto de los elementos de la matriz genérica unidimensional. |
| SetValue(Object, Int32) |
Establece un valor en el elemento situado en la posición especificada de una matriz Array unidimensional. El índice se especifica como un entero de 32 bits. |
| SetValue(Object, Int32, Int32) |
Establece un valor en el elemento situado en la posición especificada de la Array bidimensional. Los índices se especifican como enteros de 32 bits. |
| SetValue(Object, Int32, Int32, Int32) |
Establece un valor en el elemento situado en la posición especificada de la Array tridimensional. Los índices se especifican como enteros de 32 bits. |
| SetValue(Object, Int32[]) |
Establece un valor en el elemento situado en la posición especificada de una matriz Array multidimensional. Los índices se especifican en forma de una matriz de enteros de 32 bits. |
| SetValue(Object, Int64) |
Establece un valor en el elemento situado en la posición especificada de una matriz Array unidimensional. El índice se especifica como un entero de 64 bits. |
| SetValue(Object, Int64, Int64) |
Establece un valor en el elemento situado en la posición especificada de la Array bidimensional. Los índices se especifican como enteros de 64 bits. |
| SetValue(Object, Int64, Int64, Int64) |
Establece un valor en el elemento situado en la posición especificada de la Array tridimensional. Los índices se especifican como enteros de 64 bits. |
| SetValue(Object, Int64[]) |
Establece un valor en el elemento situado en la posición especificada de una matriz Array multidimensional. Los índices se especifican como matriz de enteros de 64 bits. |
| Sort(Array) |
Ordena los elementos de toda una matriz Array unidimensional usando la implementación de IComparable de cada elemento de la matriz Array. |
| Sort(Array, Array) |
Ordena un par de objetos Array unidimensionales (uno contiene las claves y el otro contiene los elementos correspondientes) en función de las claves de la primera Array usando la implementación de IComparable de cada clave. |
| Sort(Array, Array, IComparer) |
Ordena un par de objetos Array unidimensionales (uno contiene las claves y el otro contiene los elementos correspondientes) en función de las claves de la primera Array usando la IComparer. especificada. |
| Sort(Array, Array, Int32, Int32) |
Ordena un intervalo de elementos en un par de objetos Array unidimensionales (uno contiene las claves y el otro contiene los elementos correspondientes) en función de las claves de la primera matriz Array usando la implementación de IComparable de cada clave. |
| Sort(Array, Array, Int32, Int32, IComparer) |
Ordena un intervalo de elementos de un par de objetos Array unidimensionales (uno contiene las claves y el otro contiene los elementos correspondientes) en función de las claves de la primera Array usando la interfaz IComparer especificada. |
| Sort(Array, IComparer) |
Ordena los elementos de una matriz Array unidimensional usando la interfaz IComparer especificada. |
| Sort(Array, Int32, Int32) |
Ordena los elementos de un intervalo de elementos de una matriz Array unidimensional mediante el uso de la implementación de IComparable de cada elemento de la matriz Array. |
| Sort(Array, Int32, Int32, IComparer) |
Ordena los elementos de un intervalo de elementos de una matriz Array unidimensional utilizando la interfaz IComparer especificada. |
| Sort<T>(T[]) |
Ordena los elementos de toda una matriz Array usando la implementación de la interfaz genérica IComparable<T> de cada elemento de Array. |
| Sort<T>(T[], Comparison<T>) |
Ordena los elementos de una Array usando el Comparison<T> especificado. |
| Sort<T>(T[], IComparer<T>) |
Ordena los elementos de una Array usando la interfaz genérica IComparer<T> especificada. |
| Sort<T>(T[], Int32, Int32) |
Ordena los elementos en un intervalo de elementos en una Array mediante la implementación de interfaz genérica IComparable<T> de cada elemento de la Array. |
| Sort<T>(T[], Int32, Int32, IComparer<T>) |
Ordena los elementos de un intervalo de elementos en un elemento Array mediante la interfaz genérica IComparer<T> especificada. |
| Sort<TKey,TValue>(TKey[], TValue[]) |
Ordena un par de objetos Array (uno contiene las claves y el otro contiene los elementos correspondientes) en función de las claves de la primera Array usando la implementación de la interfaz genérica IComparable<T> de cada clave. |
| Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) |
Ordena un par de objetos Array (uno contiene las claves y el otro contiene los elementos correspondientes) en función de las claves de la primera matriz Array usando la interfaz genérica IComparer<T> especificada. |
| Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32) |
Ordena un intervalo de elementos en un par de objetos Array (uno contiene las claves y el otro contiene los elementos correspondientes) en función de las claves de la primera matriz Array usando la implementación de la interfaz genérica IComparable<T> de cada clave. |
| Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) |
Ordena un intervalo de elementos de un par de objetos Array (uno contiene las claves y el otro contiene los elementos correspondientes) en función de las claves de la primera matriz Array usando la interfaz genérica IComparer<T> especificada. |
| ToString() |
Devuelve una cadena que representa el objeto actual. (Heredado de Object) |
| TrueForAll<T>(T[], Predicate<T>) |
Determina si cada elemento de la matriz cumple las condiciones definidas por el predicado especificado. |
Implementaciones de interfaz explícitas
| ICollection.Count |
Obtiene el número de elementos incluidos en Array. |
| ICollection.IsSynchronized |
Obtiene un valor que indica si el acceso a Array está sincronizado (es seguro para subprocesos). |
| ICollection.SyncRoot |
Obtiene un objeto que se puede usar para sincronizar el acceso a Array. |
| IList.Add(Object) |
Cuando se llama a este método, siempre se produce una excepción NotSupportedException. |
| IList.Clear() |
Quita todos los elementos de IList. |
| IList.Contains(Object) |
Determina si un elemento se encuentra en IList. |
| IList.IndexOf(Object) |
Determina el índice de un elemento específico de IList. |
| IList.Insert(Int32, Object) |
Inserta un elemento en la interfaz IList, en el índice especificado. |
| IList.IsFixedSize |
Obtiene un valor que indica si el objeto Array tiene un tamaño fijo. |
| IList.IsReadOnly |
Obtiene un valor que indica si Array es de solo lectura. |
| IList.Item[Int32] |
Obtiene o establece el elemento en el índice especificado. |
| IList.Remove(Object) |
Quita la primera aparición de un objeto específico de la interfaz IList. |
| IList.RemoveAt(Int32) |
Quita el elemento de la interfaz IList que se encuentra en el índice especificado. |
| IStructuralComparable.CompareTo(Object, IComparer) |
Determina si el objeto de colección actual precede o sigue a otro objeto en el criterio de ordenación, o aparece en la misma posición que él. |
| IStructuralEquatable.Equals(Object, IEqualityComparer) |
Determina si un objeto especificado es igual a la instancia actual. |
| IStructuralEquatable.GetHashCode(IEqualityComparer) |
Devuelve un código hash de la instancia actual. |
Métodos de extensión
| Cast<TResult>(IEnumerable) |
Convierte los elementos de IEnumerable en el tipo especificado. |
| OfType<TResult>(IEnumerable) |
Filtra los elementos de IEnumerable en función de un tipo especificado. |
| AsParallel(IEnumerable) |
Habilita la paralelización de una consulta. |
| AsQueryable(IEnumerable) |
Convierte una interfaz IEnumerable en IQueryable. |
Se aplica a
Seguridad para subprocesos
Los miembros estáticos públicos (Shared en Visual Basic) de este tipo son seguros para subprocesos. No se garantiza que los miembros de instancia sean seguros para subprocesos.
Esta implementación no proporciona un contenedor sincronizado (seguro para subprocesos) para una clase Array. Sin embargo, las clases de .NET basadas en Array proporcionan su propia versión sincronizada de la colección mediante la SyncRoot propiedad .
Enumerar una colección no es intrínsecamente un procedimiento seguro para 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, se puede bloquear la colección durante toda la enumeración o detectar las excepciones resultantes de los cambios realizados por otros subprocesos.
Consulte también
Comentarios
Próximamente: A lo largo de 2024 iremos eliminando gradualmente las Cuestiones de GitHub como mecanismo de retroalimentación para el contenido y lo sustituiremos por un nuevo sistema de retroalimentación. Para más información, consulta: https://aka.ms/ContentUserFeedback.
Enviar y ver comentarios de