Array Třída

Reference

Definice

Obor názvů:: System

Sestavení:: System.Runtime.dll

Sestavení:: mscorlib.dll

Sestavení:: netstandard.dll

Důležité

Některé informace platí pro předběžně vydaný produkt, který se může zásadně změnit, než ho výrobce nebo autor vydá. Microsoft neposkytuje žádné záruky, výslovné ani předpokládané, týkající se zde uváděných informací.

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

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

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

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

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

public 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.IStructuralEquatable

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

type 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 IStructuralEquatable

type 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 IStructuralEquatable

Public MustInherit Class Array
Implements IList, IStructuralComparable, IStructuralEquatable

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

Public MustInherit Class Array
Implements ICloneable, IList

Dědičnost: Object
Array

Atributy: SerializableAttribute ComVisibleAttribute

Implementuje: ICollection IEnumerable IList IStructuralComparable IStructuralEquatable ICloneable

Příklady

Následující příklad kódu ukazuje, jak Array.Copy kopíruje elementy 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 objekt 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í System.Collections oborů názvů. Stále se však považuje za kolekci, protože je založená na IList rozhraní.

Třída Array je základní třídou pro jazykové implementace, které podporují pole. Nicméně pouze systém a kompilátory mohou odvozovat explicitně z Array třídy. Uživatelé by měli používat konstruktory pole poskytované jazykem.

Element je hodnota v objektu Array. Délka objektu Array je celkový počet prvků, které může obsahovat. Dolní mez objektu Array je index jeho prvního prvku. Hodnota Array může mít libovolnou dolní mez, ale ve výchozím nastavení má dolní nulu. Při vytváření instance třídy pomocí CreateInstanceje možné definovat jinou Array 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 System.Collections oborech názvů Array má pevnou kapacitu. Pokud chcete kapacitu zvýšit, musíte vytvořit nový Array objekt s požadovanou kapacitou, zkopírovat prvky ze starého Array objektu do nového a odstranit starý Arrayobjekt .

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).

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

Jednorozměrná pole implementují System.Collections.Generic.IList<T>obecná rozhraní , System.Collections.Generic.IEnumerable<T>System.Collections.Generic.ICollection<T>, System.Collections.Generic.IReadOnlyList<T> a System.Collections.Generic.IReadOnlyCollection<T> . Implementace jsou poskytovány polím za běhu a v důsledku toho se obecná rozhraní nezobrazují v syntaxi deklarace pro Array třídu. 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é je třeba vědět, když přetypujete pole na jedno z těchto rozhraní, je to, že členové, kteří přidávají, vkládají nebo odebírat elementy, vyvolají NotSupportedException.

Type objekty poskytují informace o deklarací 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ýsledkem je objekt, nikoli pole. To znamená, typeof(System.Array).IsArray že 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í typů automaticky.

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

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

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

Vlastnosti

IsFixedSize	Získá hodnotu označující, zda Array má pevnou velikost.
IsReadOnly	Získá hodnotu, která určuje, zda je Array určena jen pro čtení.
IsSynchronized	Získá hodnotu označující, zda je přístup k Array je synchronizován (bez vláken).
Length	Získá celkový počet prvků ve všech dimenzích objektu Array.
LongLength	Získá 64bitové celé číslo, které představuje celkový počet prvků ve všech dimenzích objektu Array.
MaxLength	Získá maximální počet prvků, které mohou být obsaženy v matici.
Rank	Získá pořadí (počet dimenzí) objektu Array. Například jednorozměrné pole 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 jen pro čtení pro zadané pole.
BinarySearch(Array, Int32, Int32, Object)	Vyhledá v oblasti prvků v jednorozměrném seřazené matici hodnotu pomocí IComparable rozhraní implementovaného jednotlivými prvky pole a podle zadané hodnoty.
BinarySearch(Array, Int32, Int32, Object, IComparer)	Vyhledá hodnotu v oblasti prvků v jednorozměrném seřazené matici pomocí zadaného IComparer rozhraní.
BinarySearch(Array, Object)	Prohledává celý jednorozměrný seřazený matici pro konkrétní prvek pomocí IComparable rozhraní implementovaného jednotlivými prvky pole a zadaným objektem.
BinarySearch(Array, Object, IComparer)	Vyhledá hodnotu v celém jednorozměrném seřazené matici pomocí zadaného IComparer rozhraní.
BinarySearch<T>(T[], Int32, Int32, T)	Vyhledá v oblasti prvků v jednorozměrném seřazené matici hodnotu pomocí IComparable<T> obecného rozhraní implementovaného jednotlivými prvky Array a podle zadané hodnoty.
BinarySearch<T>(T[], Int32, Int32, T, IComparer<T>)	Vyhledá hodnotu v oblasti prvků v jednorozměrném seřazené matici pomocí zadaného IComparer<T> obecného rozhraní.
BinarySearch<T>(T[], T)	Prohledává konkrétní prvek v celé jednorozměrné seřazené matici pomocí IComparable<T> obecného rozhraní implementovaného každým prvkem Array a zadaným objektem.
BinarySearch<T>(T[], T, IComparer<T>)	Vyhledá hodnotu v celém jednorozměrném seřazené matici 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 elementu.
Clone()	Vytvoří mělkou kopii souboru Array.
ConstrainedCopy(Array, Int32, Array, Int32, Int32)	Zkopíruje rozsah prvků od Array zadaného zdrojového indexu a vloží je do jiného Array počínaje zadaným cílovým indexem. Zaručuje, že všechny změny budou vráceny, pokud kopírování nebude úplně úspěšné.
ConvertAll<TInput,TOutput>(TInput[], Converter<TInput,TOutput>)	Převede pole jednoho typu na pole jiného typu.
Copy(Array, Array, Int32)	Zkopíruje rozsah elementů od Array prvního elementu a vloží je do jiného Array od prvního elementu. Délka je určena jako 32bitové celé číslo.
Copy(Array, Array, Int64)	Zkopíruje rozsah elementů od Array prvního elementu a vloží je do jiného Array od prvního elementu. Délka je zadána jako 64bitové celé číslo.
Copy(Array, Int32, Array, Int32, Int32)	Zkopíruje rozsah prvků od Array zadaného zdrojového indexu a vloží je do jiného Array počínaje zadaným cílovým indexem. Délka a indexy jsou zadány jako 32bitová celá čísla.
Copy(Array, Int64, Array, Int64, Int64)	Zkopíruje rozsah prvků od Array zadaného zdrojového indexu a vloží je do jiného Array počínaje zadaným cílovým indexem. Délka a indexy jsou zadané 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 je zadaný 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 je zadaný jako 64bitové celé číslo.
CreateInstance(Type, Int32)	Vytvoří jednorozměrnou Array hodnotu zadané Type délky a s indexováním založeným na nule.
CreateInstance(Type, Int32, Int32)	Vytvoří dvojrozměrnou Array délku zadané Type a kóty s indexováním založeným na nule.
CreateInstance(Type, Int32, Int32, Int32)	Vytvoří trojrozměrnou Array zadanou Type délku a délku dimenzí s indexováním založeným na nule.
CreateInstance(Type, Int32[])	Vytvoří multidimenzionální Array se zadanými Type délkami a délkami 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 délku zadané Type a kóty se zadanými dolními hranicemi.
CreateInstance(Type, Int64[])	Vytvoří multidimenzionální Array se zadanými Type délkami a délkami 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čí, zda se zadaný objekt rovná 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 predikátem.
Fill<T>(T[], T)	Přiřadí daný `value` typ `T` každému prvku zadaného `array`objektu .
Fill<T>(T[], T, Int32, Int32)	Přiřadí daný `value` typ `T` prvkům zadaného `array` typu, které jsou v rozsahu `startIndex` (včetně) a dalšímu `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 celém Arrayobjektu .
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í nulový index prvního výskytu v rozsahu prvků v oblasti prvků, 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í nulový index prvního výskytu v rozsahu prvků v Array oblasti, která se rozšiřuje od zadaného indexu k poslednímu elementu.
FindIndex<T>(T[], Predicate<T>)	Vyhledá prvek, který odpovídá podmínkám definovaným zadaným predikátem, a vrátí nulový index prvního výskytu v rámci celého Arrayobjektu .
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 celém Arrayobjektu .
FindLastIndex<T>(T[], Int32, Int32, Predicate<T>)	Vyhledá prvek, který odpovídá podmínkám definovaným zadaným predikátem, a vrátí nulový index posledního výskytu v rozsahu prvků v objektu 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í nulový index posledního výskytu v rozsahu prvků v Array oblasti, která se rozšiřuje od prvního prvku k zadanému indexu.
FindLastIndex<T>(T[], Predicate<T>)	Vyhledá prvek, který odpovídá podmínkám definovaným zadaným predikátem, a vrátí nulový index posledního výskytu v rámci celého Arrayobjektu .
ForEach<T>(T[], Action<T>)	Provede zadanou akci u každého prvku zadaného pole.
GetEnumerator()	Vrátí hodnotu IEnumerator pro Array.
GetHashCode()	Slouží jako výchozí hashovací funkce. (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á aktuální Type instanci. (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 Arrayobjektu . Index je zadaný jako 32bitové celé číslo.
GetValue(Int32, Int32)	Získá hodnotu na zadané pozici v dvojrozměrném Arrayobjektu . Indexy jsou udávány jako 32bitová celá čísla.
GetValue(Int32, Int32, Int32)	Získá hodnotu na zadané pozici v trojrozměrném Arrayobjektu . Indexy jsou udávány jako 32bitová celá čísla.
GetValue(Int32[])	Získá hodnotu na zadané pozici v multidimenzionální Array. Indexy jsou zadané jako pole 32bitových celých čísel.
GetValue(Int64)	Získá hodnotu na zadané pozici v jednorozměrném Arrayobjektu . Index je zadaný jako 64bitové celé číslo.
GetValue(Int64, Int64)	Získá hodnotu na zadané pozici v dvojrozměrném Arrayobjektu . Indexy jsou udávány jako 64bitová celá čísla.
GetValue(Int64, Int64, Int64)	Získá hodnotu na zadané pozici v trojrozměrném Arrayobjektu . Indexy jsou udávány jako 64bitová celá čísla.
GetValue(Int64[])	Získá hodnotu na zadané pozici v multidimenzionální Array. Indexy jsou zadané jako pole 64bitových celých čísel.
IndexOf(Array, Object)	Vyhledá zadaný objekt a vrátí index jeho 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 jeho 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 od zadaného indexu pro zadaný počet prvků.
IndexOf<T>(T[], T)	Vyhledá zadaný objekt a vrátí index jeho prvního výskytu v jednorozměrném poli.
IndexOf<T>(T[], T, Int32)	Vyhledá zadaný objekt v oblasti prvků jednorozměrného pole a vrátí index jeho 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 jeho prvního výskytu. Rozsah se rozšiřuje od zadaného indexu pro zadaný počet prvků.
Initialize()	Inicializuje každý prvek 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 Arrayobjektu .
LastIndexOf(Array, Object, Int32)	Vyhledá zadaný objekt a vrátí index posledního výskytu v rozsahu prvků v jednorozměrném Array objektu, který se rozšiřuje od prvního prvku k zadanému indexu.
LastIndexOf(Array, Object, Int32, Int32)	Vyhledá zadaný objekt a vrátí index posledního výskytu v rozsahu prvků v jednorozměrném Array objektu, 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 Arrayobjektu .
LastIndexOf<T>(T[], T, Int32)	Vyhledá zadaný objekt a vrátí index posledního výskytu v rozsahu prvků v objektu Array , který se rozšiřuje od prvního prvku k zadanému indexu.
LastIndexOf<T>(T[], T, Int32, Int32)	Vyhledá zadaný objekt a vrátí index posledního výskytu v rozsahu prvků v objektu Array , který obsahuje zadaný počet prvků a končí na zadaném indexu.
MemberwiseClone()	Vytvoří mělkou kopii aktuálního Objectsouboru . (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ém jednorozměrném Arrayobjektu .
Reverse(Array, Int32, Int32)	Obrátí sekvenci podmnožinu prvků v jednorozměrném Arrayobjektu .
Reverse<T>(T[])	Obrátí sekvenci prvků v jednorozměrném obecném poli.
Reverse<T>(T[], Int32, Int32)	Vrátí posloupnost podmnožinu prvků v jednorozměrném obecném poli.
SetValue(Object, Int32)	Nastaví hodnotu elementu na zadané pozici v jednorozměrném Arrayobjektu . Index je zadaný jako 32bitové celé číslo.
SetValue(Object, Int32, Int32)	Nastaví hodnotu elementu na zadané pozici v dvojrozměrném Arrayobjektu . Indexy jsou udávány jako 32bitová celá čísla.
SetValue(Object, Int32, Int32, Int32)	Nastaví hodnotu elementu na zadané pozici v trojrozměrném Arrayobjektu . Indexy jsou udávány jako 32bitová celá čísla.
SetValue(Object, Int32[])	Nastaví hodnotu prvku na zadané pozici v multidimenzionálním Arrayobjektu . Indexy jsou zadané jako pole 32bitových celých čísel.
SetValue(Object, Int64)	Nastaví hodnotu elementu na zadané pozici v jednorozměrném Arrayobjektu . Index je zadaný jako 64bitové celé číslo.
SetValue(Object, Int64, Int64)	Nastaví hodnotu elementu na zadané pozici v dvojrozměrném Arrayobjektu . Indexy jsou udávány jako 64bitová celá čísla.
SetValue(Object, Int64, Int64, Int64)	Nastaví hodnotu elementu na zadané pozici v trojrozměrném Arrayobjektu . Indexy jsou udávány jako 64bitová celá čísla.
SetValue(Object, Int64[])	Nastaví hodnotu prvku na zadané pozici v multidimenzionálním Arrayobjektu . Indexy jsou zadané jako pole 64bitových celých čísel.
Sort(Array)	Seřadí prvky v celém jednorozměrném Array objektu IComparable pomocí implementace každého prvku objektu Array.
Sort(Array, Array)	Seřadí dvojici jednorozměrných Array objektů (jeden obsahuje klíče a druhý odpovídající položky) na základě klíčů v prvním Array IComparable pomocí implementace každého klíče.
Sort(Array, Array, IComparer)	Seřadí dvojici jednorozměrných Array objektů (jeden obsahuje klíče a druhý odpovídající položky) na základě klíčů v prvním Array objektu pomocí zadaného IComparerobjektu .
Sort(Array, Array, Int32, Int32)	Seřadí oblast prvků ve dvojici jednorozměrných Array objektů (jeden obsahuje klíče a druhý odpovídající položky) na základě klíčů v prvním Array IComparable pomocí implementace každého klíče.
Sort(Array, Array, Int32, Int32, IComparer)	Seřadí oblast prvků ve dvojici jednorozměrných Array objektů (jeden obsahuje klíče a druhý odpovídající položky) na základě klíčů v prvním Array pomocí zadaného IComparerobjektu .
Sort(Array, IComparer)	Seřadí prvky v jednorozměrném objektu Array pomocí zadaného IComparerobjektu .
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 oblasti prvků v jednorozměrném Array objektu pomocí zadaného IComparerobjektu .
Sort<T>(T[])	Seřadí prvky v celém Array objektu IComparable<T> pomocí obecné implementace rozhraní každého prvku objektu Array.
Sort<T>(T[], Comparison<T>)	Seřadí prvky v objektu Array pomocí zadaného Comparison<T>objektu .
Sort<T>(T[], IComparer<T>)	Seřadí prvky v objektu Array pomocí zadaného IComparer<T> obecného rozhraní.
Sort<T>(T[], Int32, Int32)	Seřadí prvky v rozsahu prvků v objektu Array IComparable<T> pomocí obecné implementace rozhraní každého prvku Array.
Sort<T>(T[], Int32, Int32, IComparer<T>)	Seřadí prvky v rozsahu prvků v objektu 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ý odpovídající položky) na základě klíčů v prvním Array IComparable<T> pomocí obecné implementace rozhraní každého klíče.
Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>)	Seřadí dvojici Array objektů (jeden obsahuje klíče a druhý 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í oblast prvků ve dvojici Array objektů (jeden obsahuje klíče a druhý odpovídající položky) na základě klíčů v prvním Array IComparable<T> pomocí obecné implementace rozhraní každého klíče.
Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>)	Seřadí oblast prvků ve dvojici Array objektů (jeden obsahuje klíče a druhý 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 elementů obsažených v objektu Array.
ICollection.IsSynchronized	Získá hodnotu, která označuje, zda přístup k je Array synchronizován (bez vláken).
ICollection.SyncRoot	Získá objekt, který lze použít k synchronizaci přístupu k Array.
IList.Add(Object)	Volání této metody vždy vyvolá NotSupportedException výjimku.
IList.Clear()	Odebere všechny položky z objektu IList.
IList.Contains(Object)	Určuje, zda je prvek v objektu IList.
IList.IndexOf(Object)	Určuje index konkrétní položky v objektu IList.
IList.Insert(Int32, Object)	Vloží položku do zadaného indexu IList .
IList.IsFixedSize	Získá hodnotu, která označuje, zda Array má pevnou velikost.
IList.IsReadOnly	Získá hodnotu, která označuje, zda Array je jen pro čtení.
IList.Item[Int32]	Získá nebo nastaví prvek u zadaného indexu.
IList.Remove(Object)	Odebere první výskyt konkrétního objektu z objektu 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í, probíhá ve stejné pozici jako, nebo za jiným objektem 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 objektu na IEnumerable zadaný typ.
OfType<TResult>(IEnumerable)	Filtruje prvky objektu IEnumerable na základě zadaného typu.
AsParallel(IEnumerable)	Umožňuje paralelizaci dotazu.
AsQueryable(IEnumerable)	Převede objekt na IEnumerable IQueryable.

Platí pro

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

Veřejné statické členy (Shared v jazyce Visual Basic) tohoto typu jsou bezpečné pro přístup z více vláken. U členů instancí není zaručena bezpečnost pro přístup z více vláken.

Tato implementace neposkytuje synchronizovanou obálku (bez vláken) pro Array. Třídy .NET založené na Array však poskytují vlastní synchronizovanou verzi kolekce pomocí SyncRoot vlastnosti .

Výčet prostřednictvím kolekce nemůže být procedurou bezpečnou pro přístup z více vláken. I v případě, že jde o synchronizovanou kolekci, mohou úpravy provádět i ostatní vlákna, což způsobuje vyvolání výjimky enumerátorem. K zaručení bezpečnosti přístupu z více vláken můžete buďto zamknout kolekci na celou dobu práce s výčtem, nebo zachycovat výjimky vzniklé v důsledku změn prováděných ostatními vlákny.