Array Třída

Definice

Obor názvů:

System

Sestavení:

System.Runtime.dll

Zdroj:

Array.cs

Poskytuje metody pro vytváření, manipulaci, vyhledávání a řazení polí, čímž slouží jako základní třída pro všechna pole v modulu CLR (Common Language Runtime).

public ref class Array abstract : ICloneable, System::Collections::IList, System::Collections::IStructuralComparable, System::Collections::IStructuralEquatable

public abstract class Array : ICloneable, System.Collections.IList, System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable

type Array = class
    interface ICollection
    interface IEnumerable
    interface IList
    interface IStructuralComparable
    interface IStructuralEquatable
    interface ICloneable

Public MustInherit Class Array
Implements ICloneable, IList, IStructuralComparable, IStructuralEquatable

Dědičnost

Object

Array

Implementuje

ICollection IEnumerable IList IStructuralComparable IStructuralEquatable ICloneable

Příklady

Následující příklad kódu ukazuje, jak Array.Copy kopíruje prvky mezi polem typu integer a polem typu 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

Následující příklad kódu vytvoří a inicializuje Array a zobrazí jeho vlastnosti a jeho prvky.

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

Poznámky

Třída Array není součástí oborů názvů System.Collections. Stále se však považuje za kolekci, protože je založená na rozhraní IList.

Třída Array je základní třídou pro implementace jazyka, které podporují pole. Pouze systém a kompilátory však mohou být odvozeny explicitně z Array třídy. Uživatelé by měli používat konstrukty pole poskytované jazykem.

Prvek je hodnota v Array. Délka Array je celkový počet prvků, které může obsahovat. Dolní mez Array je index prvního prvku. Array může mít libovolnou dolní mez, ale ve výchozím nastavení má dolní mez nuly. Při vytváření instance třídy Array pomocí CreateInstancelze definovat jinou dolní mez . Multidimenzionální Array může mít pro každou dimenzi různé hranice. Pole může mít maximálně 32 dimenzí.

Na rozdíl od tříd v oborech názvů System.Collections má Array pevnou kapacitu. Chcete-li zvýšit kapacitu, musíte vytvořit nový objekt Array s požadovanou kapacitou, zkopírovat prvky ze starého objektu Array do nového objektu a odstranit starý Array.

Velikost pole je omezená na celkem 4 miliardy prvků a na maximální index 0X7FEFFFFF v libovolné dané dimenzi (0X7FFFFFC7 pro bajtová pole a pole jednobajtů struktur).

rozhraní .NET Framework: Ve výchozím nastavení je maximální velikost Array 2 gigabajty (GB). V 64bitovém prostředí se můžete vyhnout omezení velikosti nastavením enabled atributu gcAllowVeryLargeObjects konfiguračního prvku tak, aby se true v prostředí za běhu.

Jednorozměrná pole implementují System.Collections.Generic.IList<T>, System.Collections.Generic.ICollection<T>, System.Collections.Generic.IEnumerable<T>, System.Collections.Generic.IReadOnlyList<T> a System.Collections.Generic.IReadOnlyCollection<T> obecná rozhraní. Implementace jsou poskytovány polím za běhu a v důsledku toho se obecná rozhraní nezobrazují v syntaxi deklarace pro třídu Array. Kromě toho neexistují žádná referenční témata pro členy rozhraní, které jsou přístupné pouze přetypováním pole na obecný typ rozhraní (explicitní implementace rozhraní). Klíčovou věcí, o které byste měli vědět, když přetypujete pole na jedno z těchto rozhraní, je to, že členy, které přidávají, vkládají nebo odebírat prvky vyvolá NotSupportedException.

Type objekty poskytují informace o deklaracích typu pole. Array objekty se stejným typem pole sdílejí stejný Type objekt.

Type.IsArray a Type.GetElementType nemusí vrátit očekávané výsledky s Array, protože pokud je pole přetypován na typ Array, výsledek je objekt, nikoli pole. To znamená, že typeof(System.Array).IsArray vrátí falsea typeof(System.Array).GetElementType vrátí null.

Metoda Array.Copy kopíruje prvky nejen mezi poli stejného typu, ale také mezi standardními poli různých typů; zpracovává přetypování typu automaticky.

Některé metody, jako jsou CreateInstance, Copy, CopyTo, GetValuea SetValue, poskytují přetížení, která přijímají 64bitové celá čísla jako parametry pro přizpůsobení polím s velkou kapacitou. LongLength a GetLongLength vrátí 64bitová celá čísla označující délku pole.

Array není zaručeno řazení. Před provedením operací (například BinarySearch), které vyžadují řazení Array, musíte seřadit Array.

Použití Array objektu ukazatelů v nativním kódu není podporováno a vyvolá NotSupportedException pro několik metod.

Vlastnosti

IsFixedSize	Získá hodnotu určující, zda Array má pevnou velikost.
IsReadOnly	Získá hodnotu určující, zda Array je jen pro čtení.
IsSynchronized	Získá hodnotu označující, zda je přístup k Array synchronizován (bezpečné vlákno).
Length	Získá celkový počet prvků ve všech dimenzích Array.
LongLength	Získá 64bitové celé číslo, které představuje celkový počet prvků ve všech dimenzích Array.
MaxLength	Získá maximální počet prvků, které mohou být obsaženy v poli.
Rank	Získá pořadí (počet dimenzí) Array. Jednorozměrné pole například vrátí hodnotu 1, dvojrozměrné pole vrátí hodnotu 2 atd.
SyncRoot	Získá objekt, který lze použít k synchronizaci přístupu k Array.

Metody

AsReadOnly<T>(T[])	Vrátí obálku určenou jen pro čtení pro zadané pole.
BinarySearch(Array, Int32, Int32, Object)	Vyhledá oblast prvků v jednorozměrném seřazeném poli hodnotu pomocí IComparable rozhraní implementovaného každým prvkem pole a zadanou hodnotou.
BinarySearch(Array, Int32, Int32, Object, IComparer)	Vyhledá oblast prvků v jednorozměrném seřazeném poli hodnotu pomocí zadaného rozhraní IComparer.
BinarySearch(Array, Object)	Vyhledá celé jednorozměrné seřazené pole pro určitý prvek pomocí IComparable rozhraní implementovaného každým prvkem pole a zadaným objektem.
BinarySearch(Array, Object, IComparer)	Vyhledá celou jednorozměrnou seřazenou matici hodnotu pomocí zadaného rozhraní IComparer.
BinarySearch<T>(T[], Int32, Int32, T)	Vyhledá oblast prvků v jednorozměrném seřazeném poli hodnotu pomocí IComparable<T> obecného rozhraní implementovaného každým prvkem Array a zadanou hodnotou.
BinarySearch<T>(T[], Int32, Int32, T, IComparer<T>)	Vyhledá oblast prvků v jednorozměrném seřazeném poli hodnotu pomocí zadaného IComparer<T> obecného rozhraní.
BinarySearch<T>(T[], T)	Vyhledá celé jednorozměrné seřazené pole pro určitý prvek pomocí IComparable<T> obecného rozhraní implementovaného jednotlivými prvky Array a zadaným objektem.
BinarySearch<T>(T[], T, IComparer<T>)	Vyhledá celou jednorozměrnou seřazenou matici hodnotu pomocí zadaného IComparer<T> obecného rozhraní.
Clear(Array)	Vymaže obsah pole.
Clear(Array, Int32, Int32)	Nastaví rozsah prvků v poli na výchozí hodnotu každého typu prvku.
Clone()	Vytvoří mělkou kopii Array.
ConstrainedCopy(Array, Int32, Array, Int32, Int32)	Zkopíruje rozsah prvků z Array počínaje zadaným zdrojovým indexem a vloží je do jiného Array počínaje zadaným cílovým indexem. Zaručuje, že všechny změny se vrátí zpět, pokud kopírování nebude zcela úspěšné.
ConvertAll<TInput,TOutput>(TInput[], Converter<TInput,TOutput>)	Převede matici jednoho typu na pole jiného typu.
Copy(Array, Array, Int32)	Zkopíruje rozsah prvků z Array počínaje prvním prvkem a vloží je do jiného Array počínaje prvním prvkem. Délka je určena jako 32bitové celé číslo.
Copy(Array, Array, Int64)	Zkopíruje rozsah prvků z Array počínaje prvním prvkem a vloží je do jiného Array počínaje prvním prvkem. Délka je zadána jako 64bitové celé číslo.
Copy(Array, Int32, Array, Int32, Int32)	Zkopíruje rozsah prvků z Array počínaje zadaným zdrojovým indexem a vloží je do jiného Array počínaje zadaným cílovým indexem. Délka a indexy se zadají jako 32bitová celá čísla.
Copy(Array, Int64, Array, Int64, Int64)	Zkopíruje rozsah prvků z Array počínaje zadaným zdrojovým indexem a vloží je do jiného Array počínaje zadaným cílovým indexem. Délka a indexy se zadají jako 64bitová celá čísla.
CopyTo(Array, Int32)	Zkopíruje všechny prvky aktuálního jednorozměrného pole do zadaného jednorozměrného pole počínaje zadaným cílovým indexem pole. Index se zadává jako 32bitové celé číslo.
CopyTo(Array, Int64)	Zkopíruje všechny prvky aktuálního jednorozměrného pole do zadaného jednorozměrného pole počínaje zadaným cílovým indexem pole. Index se zadává jako 64bitové celé číslo.
CreateInstance(Type, Int32)	Vytvoří jednorozměrnou Array zadaného Type a délky s indexováním založeným na nule.
CreateInstance(Type, Int32, Int32)	Vytvoří dvojrozměrnou Array zadané Type a délky dimenzí s indexováním založeným na nule.
CreateInstance(Type, Int32, Int32, Int32)	Vytvoří trojrozměrnou Array zadané Type a délky dimenzí s indexováním založeným na nule.
CreateInstance(Type, Int32[])	Vytvoří multidimenzionální Array zadané Type a délky dimenzí s indexováním založeným na nule. Délky dimenzí jsou zadány v poli 32bitových celých čísel.
CreateInstance(Type, Int32[], Int32[])	Vytvoří multidimenzionální Array zadané Type a délky dimenzí se zadanými dolními hranicemi.
CreateInstance(Type, Int64[])	Vytvoří multidimenzionální Array zadané Type a délky dimenzí s indexováním založeným na nule. Délky dimenzí jsou zadány v poli 64bitových celých čísel.
Empty<T>()	Vrátí prázdnou matici.
Equals(Object)	Určuje, zda je zadaný objekt roven aktuálnímu objektu. (Zděděno od Object)
Exists<T>(T[], Predicate<T>)	Určuje, zda zadané pole obsahuje prvky, které odpovídají podmínkám definovaným zadaným predikátem.
Fill<T>(T[], T)	Přiřadí daný value typu T každému prvku zadaného array.
Fill<T>(T[], T, Int32, Int32)	Přiřadí daný value typu T prvkům zadaného array, které jsou v rozsahu startIndex (včetně) a dalšího count počtu indexů.
Find<T>(T[], Predicate<T>)	Vyhledá prvek, který odpovídá podmínkám definovaným zadaným predikátem, a vrátí první výskyt v rámci celého Array.
FindAll<T>(T[], Predicate<T>)	Načte všechny prvky, které odpovídají podmínkám definovaným zadaným predikátem.
FindIndex<T>(T[], Int32, Int32, Predicate<T>)	Vyhledá prvek, který odpovídá podmínkám definovaným zadaným predikátem, a vrátí index založený na nule prvního výskytu v rozsahu prvků v Array, který začíná na zadaném indexu a obsahuje zadaný počet prvků.
FindIndex<T>(T[], Int32, Predicate<T>)	Vyhledá prvek, který odpovídá podmínkám definovaným zadaným predikátem, a vrátí index založený na nule prvního výskytu v rozsahu prvků v Array, který se vztahuje ze zadaného indexu na poslední prvek.
FindIndex<T>(T[], Predicate<T>)	Vyhledá prvek, který odpovídá podmínkám definovaným zadaným predikátem, a vrátí index založený na nule prvního výskytu v rámci celého Array.
FindLast<T>(T[], Predicate<T>)	Vyhledá prvek, který odpovídá podmínkám definovaným zadaným predikátem, a vrátí poslední výskyt v rámci celého Array.
FindLastIndex<T>(T[], Int32, Int32, Predicate<T>)	Vyhledá prvek, který odpovídá podmínkám definovaným zadaným predikátem, a vrátí index založený na nule posledního výskytu v rozsahu prvků v Array, který obsahuje zadaný počet prvků a končí na zadaném indexu.
FindLastIndex<T>(T[], Int32, Predicate<T>)	Vyhledá prvek, který odpovídá podmínkám definovaným zadaným predikátem, a vrátí index založený na nule posledního výskytu v rozsahu prvků v Array, který přesahuje první prvek na zadaný index.
FindLastIndex<T>(T[], Predicate<T>)	Vyhledá prvek, který odpovídá podmínkám definovaným zadaným predikátem, a vrátí index založený na nule posledního výskytu v rámci celého Array.
ForEach<T>(T[], Action<T>)	Provede zadanou akci pro každý prvek zadaného pole.
GetEnumerator()	Vrátí IEnumerator pro Array.
GetHashCode()	Slouží jako výchozí funkce hash. (Zděděno od Object)
GetLength(Int32)	Získá 32bitové celé číslo, které představuje počet prvků v zadané dimenzi Array.
GetLongLength(Int32)	Získá 64bitové celé číslo, které představuje počet prvků v zadané dimenzi Array.
GetLowerBound(Int32)	Získá index prvního prvku zadané dimenze v poli.
GetType()	Získá Type aktuální instance. (Zděděno od Object)
GetUpperBound(Int32)	Získá index posledního prvku zadané dimenze v poli.
GetValue(Int32)	Získá hodnotu na zadané pozici v jednorozměrném Array. Index se zadává jako 32bitové celé číslo.
GetValue(Int32, Int32)	Získá hodnotu na zadané pozici v dvojrozměrném Array. Indexy se zadají jako 32bitová celá čísla.
GetValue(Int32, Int32, Int32)	Získá hodnotu na zadané pozici v trojrozměrné Array. Indexy se zadají jako 32bitová celá čísla.
GetValue(Int32[])	Získá hodnotu na zadané pozici v multidimenzionální Array. Indexy se zadají jako pole 32bitových celých čísel.
GetValue(Int64)	Získá hodnotu na zadané pozici v jednorozměrném Array. Index se zadává jako 64bitové celé číslo.
GetValue(Int64, Int64)	Získá hodnotu na zadané pozici v dvojrozměrném Array. Indexy se zadají jako 64bitová celá čísla.
GetValue(Int64, Int64, Int64)	Získá hodnotu na zadané pozici v trojrozměrné Array. Indexy se zadají jako 64bitová celá čísla.
GetValue(Int64[])	Získá hodnotu na zadané pozici v multidimenzionální Array. Indexy se zadají jako pole 64bitových celých čísel.
IndexOf(Array, Object)	Vyhledá zadaný objekt a vrátí index prvního výskytu v jednorozměrném poli.
IndexOf(Array, Object, Int32)	Vyhledá zadaný objekt v rozsahu prvků jednorozměrného pole a vrátí index prvního výskytu. Rozsah se rozšiřuje od zadaného indexu na konec pole.
IndexOf(Array, Object, Int32, Int32)	Vyhledá zadaný objekt v rozsahu prvků jednorozměrného pole a vrátí index prvního výskytu ifs. Rozsah se rozšiřuje ze zadaného indexu pro zadaný počet prvků.
IndexOf<T>(T[], T)	Vyhledá zadaný objekt a vrátí index prvního výskytu v jednorozměrném poli.
IndexOf<T>(T[], T, Int32)	Vyhledá zadaný objekt v rozsahu prvků jednorozměrného pole a vrátí index prvního výskytu. Rozsah se rozšiřuje od zadaného indexu na konec pole.
IndexOf<T>(T[], T, Int32, Int32)	Vyhledá zadaný objekt v rozsahu prvků jednorozměrného pole a vrátí index prvního výskytu. Rozsah se rozšiřuje ze zadaného indexu pro zadaný počet prvků.
Initialize()	Inicializuje všechny prvky typu value-type Array voláním konstruktoru bez parametrů typu hodnoty.
LastIndexOf(Array, Object)	Vyhledá zadaný objekt a vrátí index posledního výskytu v rámci celého jednorozměrného Array.
LastIndexOf(Array, Object, Int32)	Vyhledá zadaný objekt a vrátí index posledního výskytu v rozsahu prvků v jednorozměrném Array, který se rozšiřuje z prvního prvku na zadaný index.
LastIndexOf(Array, Object, Int32, Int32)	Vyhledá zadaný objekt a vrátí index posledního výskytu v rozsahu prvků v jednorozměrném Array, který obsahuje zadaný počet prvků a končí na zadaném indexu.
LastIndexOf<T>(T[], T)	Vyhledá zadaný objekt a vrátí index posledního výskytu v celém Array.
LastIndexOf<T>(T[], T, Int32)	Vyhledá zadaný objekt a vrátí index posledního výskytu v rozsahu prvků v Array, který se rozšiřuje z prvního prvku na zadaný index.
LastIndexOf<T>(T[], T, Int32, Int32)	Vyhledá zadaný objekt a vrátí index posledního výskytu v rozsahu prvků v Array, který obsahuje zadaný počet prvků a končí na zadaném indexu.
MemberwiseClone()	Vytvoří mělkou kopii aktuálního Object. (Zděděno od Object)
Resize<T>(T[], Int32)	Změní počet prvků jednorozměrného pole na zadanou novou velikost.
Reverse(Array)	Obrátí sekvenci prvků v celé jednorozměrné Array.
Reverse(Array, Int32, Int32)	Obrátí sekvenci podmnožinu prvků v jednorozměrném Array.
Reverse<T>(T[])	Obrátí sekvenci prvků v jednorozměrném obecném poli.
Reverse<T>(T[], Int32, Int32)	Obrátí sekvenci podmnožinu prvků v jednorozměrném obecném poli.
SetValue(Object, Int32)	Nastaví hodnotu prvku na zadané pozici v jednorozměrném Array. Index se zadává jako 32bitové celé číslo.
SetValue(Object, Int32, Int32)	Nastaví hodnotu prvku na zadané pozici v dvojrozměrném Array. Indexy se zadají jako 32bitová celá čísla.
SetValue(Object, Int32, Int32, Int32)	Nastaví hodnotu prvku na zadané pozici v trojrozměrném Array. Indexy se zadají jako 32bitová celá čísla.
SetValue(Object, Int32[])	Nastaví hodnotu prvku na zadané pozici v multidimenzionálním Array. Indexy se zadají jako pole 32bitových celých čísel.
SetValue(Object, Int64)	Nastaví hodnotu prvku na zadané pozici v jednorozměrném Array. Index se zadává jako 64bitové celé číslo.
SetValue(Object, Int64, Int64)	Nastaví hodnotu prvku na zadané pozici v dvojrozměrném Array. Indexy se zadají jako 64bitová celá čísla.
SetValue(Object, Int64, Int64, Int64)	Nastaví hodnotu prvku na zadané pozici v trojrozměrném Array. Indexy se zadají jako 64bitová celá čísla.
SetValue(Object, Int64[])	Nastaví hodnotu prvku na zadané pozici v multidimenzionálním Array. Indexy se zadají jako pole 64bitových celých čísel.
Sort(Array)	Seřadí prvky v celém jednorozměrném Array pomocí IComparable implementace každého prvku Array.
Sort(Array, Array)	Seřadí dvojici jednorozměrných Array objektů (jeden obsahuje klíče a druhý obsahuje odpovídající položky) na základě klíčů v prvním Array pomocí IComparable implementace každého klíče.
Sort(Array, Array, IComparer)	Seřadí dvojici jednorozměrných Array objektů (jeden obsahuje klíče a druhý obsahuje odpovídající položky) na základě klíčů v prvním Array pomocí zadaného IComparer.
Sort(Array, Array, Int32, Int32)	Seřadí rozsah prvků v páru jednorozměrných Array objektů (jeden obsahuje klíče a druhý obsahuje odpovídající položky) na základě klíčů v prvním Array pomocí IComparable implementace každého klíče.
Sort(Array, Array, Int32, Int32, IComparer)	Seřadí rozsah prvků v páru jednorozměrných Array objektů (jeden obsahuje klíče a druhý obsahuje odpovídající položky) na základě klíčů v prvním Array pomocí zadané IComparer.
Sort(Array, IComparer)	Seřadí prvky v jednorozměrném Array pomocí zadaného IComparer.
Sort(Array, Int32, Int32)	Seřadí prvky v rozsahu prvků v jednorozměrném Array pomocí IComparable implementace každého prvku Array.
Sort(Array, Int32, Int32, IComparer)	Seřadí prvky v rozsahu prvků v jednorozměrném Array pomocí zadaného IComparer.
Sort<T>(T[])	Seřadí prvky v celém Array pomocí IComparable<T> obecné rozhraní implementace každého prvku Array.
Sort<T>(T[], Comparison<T>)	Seřadí prvky v Array pomocí zadaného Comparison<T>.
Sort<T>(T[], IComparer<T>)	Seřadí prvky v Array pomocí zadaného IComparer<T> obecného rozhraní.
Sort<T>(T[], Int32, Int32)	Seřadí prvky v rozsahu prvků v Array pomocí IComparable<T> obecné rozhraní implementace každého prvku Array.
Sort<T>(T[], Int32, Int32, IComparer<T>)	Seřadí prvky v rozsahu prvků v Array pomocí zadaného IComparer<T> obecného rozhraní.
Sort<TKey,TValue>(TKey[], TValue[])	Seřadí dvojici Array objektů (jeden obsahuje klíče a druhá obsahuje odpovídající položky) na základě klíčů v prvním Array pomocí IComparable<T> implementace obecného rozhraní každého klíče.
Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>)	Seřadí dvojici Array objektů (jeden obsahuje klíče a druhý obsahuje odpovídající položky) na základě klíčů v prvním Array pomocí zadaného IComparer<T> obecného rozhraní.
Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32)	Seřadí rozsah prvků v páru Array objektů (jeden obsahuje klíče a druhý obsahuje odpovídající položky) na základě klíčů v prvním Array pomocí IComparable<T> implementace obecného rozhraní každého klíče.
Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>)	Seřadí rozsah prvků v páru Array objektů (jeden obsahuje klíče a druhý obsahuje odpovídající položky) na základě klíčů v prvním Array pomocí zadaného IComparer<T> obecného rozhraní.
ToString()	Vrátí řetězec, který představuje aktuální objekt. (Zděděno od Object)
TrueForAll<T>(T[], Predicate<T>)	Určuje, zda každý prvek v poli odpovídá podmínkám definovaným zadaným predikátem.

Explicitní implementace rozhraní

ICollection.Count	Získá počet prvků obsažených v Array.
IList.Add(Object)	Volání této metody vždy vyvolá výjimku NotSupportedException.
IList.Clear()	Odebere všechny položky z IList.
IList.Contains(Object)	Určuje, zda je prvek v IList.
IList.IndexOf(Object)	Určuje index konkrétní položky v IList.
IList.Insert(Int32, Object)	Vloží položku do IList v zadaném indexu.
IList.Item[Int32]	Získá nebo nastaví prvek v zadaném indexu.
IList.Remove(Object)	Odebere první výskyt konkrétního objektu z IList.
IList.RemoveAt(Int32)	Odebere IList položku v zadaném indexu.
IStructuralComparable.CompareTo(Object, IComparer)	Určuje, zda aktuální objekt kolekce předchází, nastane ve stejné pozici jako nebo následuje jiný objekt v pořadí řazení.
IStructuralEquatable.Equals(Object, IEqualityComparer)	Určuje, zda je objekt roven aktuální instanci.
IStructuralEquatable.GetHashCode(IEqualityComparer)	Vrátí kód hash pro aktuální instanci.

Metody rozšíření

Cast<TResult>(IEnumerable)	Přetypuje prvky IEnumerable na zadaný typ.
OfType<TResult>(IEnumerable)	Filtruje prvky IEnumerable na základě zadaného typu.
AsParallel(IEnumerable)	Umožňuje paralelizaci dotazu.
AsQueryable(IEnumerable)	Převede IEnumerable na IQueryable.

Bezpečný přístup z více vláken

Veřejné statické (Shared v jazyce Visual Basic) tohoto typu jsou bezpečné pro přístup z více vláken. U všech členů instance není zaručeno, že budou bezpečné pro přístup z více vláken.

Tato implementace neposkytuje synchronizovaný (bezpečný vlákno) obálku pro Array; třídy .NET založené na Array však poskytují vlastní synchronizovanou verzi kolekce pomocí vlastnosti SyncRoot.

Výčet prostřednictvím kolekce není vnitřně bezpečným postupem pro přístup z více vláken. I když je kolekce synchronizována, ostatní vlákna mohou stále upravovat kolekci, což způsobí, že enumerátor vyvolá výjimku. Chcete-li zaručit bezpečnost vláken během výčtu, můžete buď uzamknout kolekci během celého výčtu, nebo zachytit výjimky vyplývající z změn provedených jinými vlákny.

Viz také

• Object
• Type
• provádění operací s řetězci Culture-Insensitive v polích
• polí (Průvodce programováním v C#)
• pole v jazyce F#
• pole v jazyce Visual Basic