Array Třída

Definice

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 : 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
Array
Atributy
Implementuje

Příklady

Následující příklad kódu ukazuje, jak Array.Copy kopíruje prvky mezi polem typu integer a pole 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í System.Collections oborů názvů. Stále se ale považuje za kolekci, protože je založená na IList rozhraní.

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

Prvek je hodnota v objektu Array. Délka Array je celkový počet prvků, které může obsahovat. Dolní mez je Array index prvního prvku. Může Array mít libovolnou dolní mez, ale ve výchozím nastavení má dolní mez nuly. Při vytváření instance Array třídy pomocí CreateInstance. 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. Chcete-li zvýšit kapacitu, musíte vytvořit nový Array objekt s požadovanou kapacitou, zkopírovat prvky ze starého Array objektu 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).

.NET Framework pouze: 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 v true prostředí za běhu.

Jednorozměrná pole implementují System.Collections.Generic.IList<T>rozhraní , 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 třídy 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 členové, které přidávají, vkládají nebo odebírat elementy vyvolá 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, Array protože pokud je matice přetypována na typ Array, výsledek je objekt, nikoli matice. 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, jako CreateInstanceje , , Copy, GetValueCopyToa SetValue, poskytují přetížení, které přijímají 64bitové celé číslo jako parametry pro přizpůsobení velkých polí kapacity. LongLength a GetLongLength vrátí 64bitové celé číslo označující délku pole.

Není Array zaručeno řazení. Před provedením operací (napříkladBinarySearch) musíte seřaditArray, které vyžadují Array řazení.

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

Vlastnosti

IsFixedSize

Získá hodnotu urč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 ho 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 objektu 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čísla . 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 určenou pro zadané pole jen pro čtení.

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 IComparer rozhraní.

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 matici seřazenou hodnotu pomocí zadaného IComparer rozhraní.

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 jednotlivými prvky 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 objektu Array a zadaného objektu.

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 matici na výchozí hodnotu každého typu prvku.

Clone()

Vytvoří mělké kopie 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 se vrátí zpět, pokud kopírování nebude úspěšně ú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 prvků od prvního elementu Array a vloží je do jiného Array prvku začínajícího prvním prvkem. Délka je zadána jako 32bitové celé číslo.

Copy(Array, Array, Int64)

Zkopíruje rozsah prvků od prvního elementu Array a vloží je do jiného Array prvku začínajícího prvním prvkem. 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é číslo.

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 zadány jako 64bitové celé číslo.

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 zadán 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 zadán jako 64bitové celé číslo.

CreateInstance(Type, Int32)

Vytvoří jednorozměrnou Array hodnotu zadaného Type a dlouhého indexování s nulovým indexováním.

CreateInstance(Type, Int32, Int32)

Vytvoří dvourozměrnou Array délku zadané Type a rozměrové délky s indexováním založeným na nule.

CreateInstance(Type, Int32, Int32, Int32)

Vytvoří trojrozměrné Array délky zadaných Type a dimenzí s indexováním založeným na nule.

CreateInstance(Type, Int32[])

Vytvoří multidimenzionální Array hodnotu zadané Type délky 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 hodnoty zadané Type délky a délky dimenzí se zadanými dolními hranicemi.

CreateInstance(Type, Int64[])

Vytvoří multidimenzionální Array hodnotu zadané Type délky 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čí, 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 zadaným predikátem.

Fill<T>(T[], T)

Přiřadí daný value typ T každému prvku zadaného arrayprvku .

Fill<T>(T[], T, Int32, Int32)

Přiřadí daný value typ prvkům zadaného array typuT, 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 rámci celého Arraysouboru .

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ů, 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 rozsahu prvků, 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í nulový index 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ů, 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 rozsahu prvků, který se rozšiřuje od prvního prvku 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í nulový index posledního výskytu v rámci celého Arraysouboru .

ForEach<T>(T[], Action<T>)

Provede zadanou akci pro každý prvek zadaného pole.

GetEnumerator()

IEnumerator Vrátí hodnotu 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()

Type Získá aktuální 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é Array. Index je zadán jako 32bitové celé číslo.

GetValue(Int32, Int32)

Získá hodnotu na zadané pozici v dvojrozměrné Array. 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 se zadají jako pole 32bitových celých čísel.

GetValue(Int64)

Získá hodnotu na zadané pozici v jednorozměrné Array. Index je zadán jako 64bitové celé číslo.

GetValue(Int64, Int64)

Získá hodnotu na zadané pozici v dvojrozměrné Array. 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 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 ze 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 argumentu ifs first occurrence. 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 oblasti prvků jednoho dimenzionální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 oblasti prvků jednorozměrného pole a vrátí index prvního výskytu. Rozsah se rozšiřuje od zadaného indexu pro zadaný počet prvků.

Initialize()

Inicializuje každý prvek typu Array hodnota 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 dimenzionální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 prvku, který se rozšiřuje od 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 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 Array rozsahu prvků, který se rozšiřuje od 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ů, Array který obsahuje zadaný počet prvků a končí na zadaném indexu.

MemberwiseClone()

Vytvoří použádnou kopii aktuálního souboru 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)

Vrátí sekvenci prvků v celé jednorozměrné dimenzionální Arraysadě .

Reverse(Array, Int32, Int32)

Vrátí sekvenci podmnožinu prvků v jednorozměrném Arrayobjektu .

Reverse<T>(T[])

Vrátí sekvenci prvků v jednorozměrném obecném poli.

Reverse<T>(T[], Int32, Int32)

Vrá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 Arrayobjektu . Index je zadán jako 32bitové celé číslo.

SetValue(Object, Int32, Int32)

Nastaví hodnotu prvku na zadané pozici v dvojrozměrném Arrayobjektu . Indexy jsou udávány jako 32bitová celá čísla.

SetValue(Object, Int32, Int32, Int32)

Nastaví hodnotu prvku 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í Array. Indexy se zadají jako pole 32bitových celých čísel.

SetValue(Object, Int64)

Nastaví hodnotu prvku na zadané pozici v jednorozměrném Arrayobjektu . Index je zadán jako 64bitové celé číslo.

SetValue(Object, Int64, Int64)

Nastaví hodnotu prvku na zadané pozici v dvojrozměrném Arrayobjektu . Indexy jsou udávány jako 64bitová celá čísla.

SetValue(Object, Int64, Int64, Int64)

Nastaví hodnotu prvku 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í Array. Indexy se zadají jako pole 64bitových celých čísel.

Sort(Array)

Seřadí prvky v celé jednorozměrné Array IComparable implementaci jednotlivých prvků 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 použití 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 použití zadaného IComparerobjektu .

Sort(Array, Array, Int32, Int32)

Seřadí rozsah prvků ve 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 použití IComparable implementace každého klíče.

Sort(Array, Array, Int32, Int32, IComparer)

Seřadí rozsah prvků ve 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 použití zadaného IComparerobjektu .

Sort(Array, IComparer)

Seřadí prvky v jednorozměrném Array objektu pomocí zadaného IComparerobjektu .

Sort(Array, Int32, Int32)

Seřadí prvky v rozsahu prvků v jednorozměrném Array použití IComparable implementace každého prvku Array.

Sort(Array, Int32, Int32, IComparer)

Seřadí prvky v rozsahu 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 Array.

Sort<T>(T[], Comparison<T>)

Seřadí prvky v zadaném objektu Array Comparison<T>.

Sort<T>(T[], IComparer<T>)

Seřadí prvky v zadaném obecném Array IComparer<T> rozhraní.

Sort<T>(T[], Int32, Int32)

Seřadí prvky v rozsahu prvků v Array použití 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 zadaném obecném IComparer<T> 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> 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ý 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ů ve dvojici Array objektů (jeden obsahuje klíče a druhý obsahuje odpovídající položky) na základě klíčů v prvním Array použití IComparable<T> obecné implementace rozhraní každého klíče.

Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>)

Seřadí rozsah prvků ve dvojici Array objektů (jeden obsahuje klíče a druhý obsahuje odpovídající položky) na základě klíčů v prvním Array použití 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 je přístup k synchronizaci Array (vlákno bezpečné).

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 položky 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í, dochází ve stejné pozici jako nebo se řídí 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 aktuální instance.

Metody rozšíření

Cast<TResult>(IEnumerable)

Přetypuje prvky zadaného IEnumerable typu.

OfType<TResult>(IEnumerable)

Filtruje prvky IEnumerable založené na zadaném typu.

AsParallel(IEnumerable)

Umožňuje paralelizaci dotazu.

AsQueryable(IEnumerable)

Převede na IEnumerable IQueryable.

Platí pro

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

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

Tato implementace neposkytuje synchronizovaný obálku (bezpečný pro vlákno) pro objekt Array; třídy .NET však na Array základě toho, že 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.

Viz také