Array Klasa

Definicja

Przestrzeń nazw:

System

Zestaw:

System.Runtime.dll

Źródło:

Array.cs

Udostępnia metody tworzenia, manipulowania, wyszukiwania i sortowania tablic, służąc tym samym jako klasa bazowa dla wszystkich tablic w środowisku uruchomieniowym języka wspólnego.

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

Dziedziczenie

Object

Array

Implementuje

ICollection IEnumerable IList IStructuralComparable IStructuralEquatable ICloneable

Przykłady

Poniższy przykład kodu pokazuje, jak Array.Copy kopiuje elementy między tablicą typu liczba całkowita i tablica 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

Poniższy przykład kodu tworzy i inicjuje Array i wyświetla jego właściwości i jego elementy.

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

Uwagi

Klasa Array nie jest częścią przestrzeni nazw System.Collections. Jednak nadal jest traktowana jako kolekcja, ponieważ jest oparta na interfejsie IList.

Klasa Array jest klasą bazową implementacji języków, które obsługują tablice. Jednak tylko system i kompilatory mogą pochodzić jawnie z klasy Array. Użytkownicy powinni stosować konstrukcje tablic dostarczone przez język.

Element jest wartością w Array. Długość Array to całkowita liczba elementów, które może zawierać. Dolna granica Array jest indeksem pierwszego elementu. Array może mieć dowolną dolną granicę, ale domyślnie ma dolną granicę zera. Podczas tworzenia wystąpienia klasy Array można zdefiniować inną dolną granicę przy użyciu CreateInstance. Wielowymiarowe Array mogą mieć różne granice dla każdego wymiaru. Tablica może mieć maksymalnie 32 wymiary.

W przeciwieństwie do klas w przestrzeniach nazw System.CollectionsArray ma stałą pojemność. Aby zwiększyć pojemność, należy utworzyć nowy obiekt Array z wymaganą pojemnością, skopiować elementy ze starego obiektu Array do nowego i usunąć stary Array.

Rozmiar tablicy jest ograniczony do sumy 4 miliardów elementów i do maksymalnego indeksu 0X7FEFFFFF w dowolnym wymiarze (0X7FFFFFC7 dla tablic bajtowych i tablic struktur jedno bajtowych).

tylko program .NET Framework: Domyślnie maksymalny rozmiar Array wynosi 2 gigabajty (GB). W środowisku 64-bitowym można uniknąć ograniczenia rozmiaru, ustawiając atrybut enabledgcAllowVeryLargeObjects elementu konfiguracji, aby true w środowisku czasu wykonywania.

Tablice jednowymiarowe implementują interfejsy ogólne System.Collections.Generic.IList<T>, System.Collections.Generic.ICollection<T>, System.Collections.Generic.IEnumerable<T>, System.Collections.Generic.IReadOnlyList<T> i System.Collections.Generic.IReadOnlyCollection<T>. Implementacje są dostarczane do tablic w czasie wykonywania, a w rezultacie interfejsy ogólne nie są wyświetlane w składni deklaracji dla klasy Array. Ponadto nie ma tematów referencyjnych dla elementów członkowskich interfejsu, które są dostępne tylko przez rzutowanie tablicy do ogólnego typu interfejsu (jawne implementacje interfejsu). Kluczową rzeczą, o której należy pamiętać podczas rzutowania tablicy do jednego z tych interfejsów, jest to, że elementy członkowskie, które dodają, wstawią lub usuwają elementy zgłaszają NotSupportedException.

Type obiekty zawierają informacje o deklaracjach typów tablicy. Array obiektów o tym samym typie tablicy współużytkuje ten sam obiekt Type.

Type.IsArray i Type.GetElementType mogą nie zwracać oczekiwanych wyników z Array, ponieważ jeśli tablica jest rzutowania do typu Array, wynik jest obiektem, a nie tablicą. Oznacza to, że funkcja typeof(System.Array).IsArray zwraca wartość false, a typeof(System.Array).GetElementType zwraca wartość null.

Metoda Array.Copy kopiuje elementy nie tylko między tablicami tego samego typu, ale także między standardowymi tablicami różnych typów; obsługuje automatyczne rzutowanie typu.

Niektóre metody, takie jak CreateInstance, Copy, CopyTo, GetValuei SetValue, zapewniają przeciążenia, które akceptują 64-bitowe liczby całkowite jako parametry, aby pomieścić duże tablice pojemności. LongLength i GetLongLength zwracają 64-bitowe liczby całkowite wskazujące długość tablicy.

Nie ma gwarancji sortowania Array. Należy posortować Array przed wykonaniem operacji (takich jak BinarySearch), które wymagają sortowania Array.

Używanie obiektu Array wskaźników w kodzie natywnym nie jest obsługiwane i zgłasza NotSupportedException dla kilku metod.

Właściwości

IsFixedSize	Pobiera wartość wskazującą, czy Array ma stały rozmiar.
IsReadOnly	Pobiera wartość wskazującą, czy Array jest tylko do odczytu.
IsSynchronized	Pobiera wartość wskazującą, czy dostęp do Array jest synchronizowany (bezpieczny wątek).
Length	Pobiera łączną liczbę elementów we wszystkich wymiarach Array.
LongLength	Pobiera 64-bitową liczbę całkowitą elementów we wszystkich wymiarach Array.
MaxLength	Pobiera maksymalną liczbę elementów, które mogą być zawarte w tablicy.
Rank	Pobiera rangę (liczbę wymiarów) Array. Na przykład tablica jednowymiarowa zwraca wartość 1, tablica dwuwymiarowa zwraca wartość 2 itd.
SyncRoot	Pobiera obiekt, który może służyć do synchronizowania dostępu do Array.

Metody

AsReadOnly<T>(T[])	Zwraca otokę tylko do odczytu dla określonej tablicy.
BinarySearch(Array, Int32, Int32, Object)	Wyszukuje szereg elementów w jednowymiarowej tablicy posortowanej dla wartości przy użyciu interfejsu IComparable zaimplementowanego przez każdy element tablicy i przez określoną wartość.
BinarySearch(Array, Int32, Int32, Object, IComparer)	Wyszukuje zakres elementów w jednowymiarowej tablicy posortowanej dla wartości przy użyciu określonego interfejsu IComparer.
BinarySearch(Array, Object)	Wyszukuje całą jednowymiarową tablicę posortowaną dla określonego elementu przy użyciu interfejsu IComparable zaimplementowanego przez każdy element tablicy i przez określony obiekt.
BinarySearch(Array, Object, IComparer)	Wyszukuje całą jednowymiarową tablicę posortowaną dla wartości przy użyciu określonego interfejsu IComparer.
BinarySearch<T>(T[], Int32, Int32, T)	Wyszukuje szereg elementów w jednowymiarowej tablicy posortowanej dla wartości przy użyciu interfejsu ogólnego IComparable<T> zaimplementowanego przez każdy element Array i przez określoną wartość.
BinarySearch<T>(T[], Int32, Int32, T, IComparer<T>)	Wyszukuje szereg elementów w jednowymiarowej tablicy posortowanej dla wartości przy użyciu określonego interfejsu ogólnego IComparer<T>.
BinarySearch<T>(T[], T)	Wyszukuje całą jednowymiarową tablicę posortowaną dla określonego elementu przy użyciu interfejsu ogólnego IComparable<T> zaimplementowanego przez każdy element Array i określony obiekt.
BinarySearch<T>(T[], T, IComparer<T>)	Wyszukuje całą jednowymiarową tablicę posortowaną dla wartości przy użyciu określonego interfejsu ogólnego IComparer<T>.
Clear(Array)	Czyści zawartość tablicy.
Clear(Array, Int32, Int32)	Ustawia zakres elementów w tablicy na wartość domyślną każdego typu elementu.
Clone()	Tworzy płytkią kopię Array.
ConstrainedCopy(Array, Int32, Array, Int32, Int32)	Kopiuje szereg elementów z Array rozpoczynających się od określonego indeksu źródłowego i wkleja je do innego Array rozpoczynającego się od określonego indeksu docelowego. Gwarantuje, że wszystkie zmiany zostaną cofnięte, jeśli kopia nie powiedzie się całkowicie.
ConvertAll<TInput,TOutput>(TInput[], Converter<TInput,TOutput>)	Konwertuje tablicę jednego typu na tablicę innego typu.
Copy(Array, Array, Int32)	Kopiuje szereg elementów z Array rozpoczynających się od pierwszego elementu i wkleja je do innego Array rozpoczynającego się od pierwszego elementu. Długość jest określana jako 32-bitowa liczba całkowita.
Copy(Array, Array, Int64)	Kopiuje szereg elementów z Array rozpoczynających się od pierwszego elementu i wkleja je do innego Array rozpoczynającego się od pierwszego elementu. Długość jest określana jako 64-bitowa liczba całkowita.
Copy(Array, Int32, Array, Int32, Int32)	Kopiuje szereg elementów z Array rozpoczynających się od określonego indeksu źródłowego i wkleja je do innego Array rozpoczynającego się od określonego indeksu docelowego. Długość i indeksy są określane jako 32-bitowe liczby całkowite.
Copy(Array, Int64, Array, Int64, Int64)	Kopiuje szereg elementów z Array rozpoczynających się od określonego indeksu źródłowego i wkleja je do innego Array rozpoczynającego się od określonego indeksu docelowego. Długość i indeksy są określane jako 64-bitowe liczby całkowite.
CopyTo(Array, Int32)	Kopiuje wszystkie elementy bieżącej tablicy jednowymiarowej do określonej jednowymiarowej tablicy rozpoczynającej się od określonego indeksu tablicy docelowej. Indeks jest określony jako 32-bitowa liczba całkowita.
CopyTo(Array, Int64)	Kopiuje wszystkie elementy bieżącej tablicy jednowymiarowej do określonej jednowymiarowej tablicy rozpoczynającej się od określonego indeksu tablicy docelowej. Indeks jest określany jako 64-bitowa liczba całkowita.
CreateInstance(Type, Int32)	Tworzy jednowymiarową Array określonej Type i długości z indeksowaniem zerowym.
CreateInstance(Type, Int32, Int32)	Tworzy dwuwymiarową Array określonej Type i długości wymiarów z indeksowaniem zerowym.
CreateInstance(Type, Int32, Int32, Int32)	Tworzy trójwymiarową Array określonej Type i długości wymiarów z indeksowaniem zerowym.
CreateInstance(Type, Int32[])	Tworzy wielowymiarową Array określonej Type i długości wymiarów z indeksowaniem zerowym. Długości wymiarów są określone w tablicy 32-bitowych liczb całkowitych.
CreateInstance(Type, Int32[], Int32[])	Tworzy wielowymiarowe Array określonych Type i długości wymiarów z określonymi dolnymi granicami.
CreateInstance(Type, Int64[])	Tworzy wielowymiarową Array określonej Type i długości wymiarów z indeksowaniem zerowym. Długości wymiarów są określane w tablicy 64-bitowych liczb całkowitych.
Empty<T>()	Zwraca pustą tablicę.
Equals(Object)	Określa, czy określony obiekt jest równy bieżącemu obiektowi. (Odziedziczone po Object)
Exists<T>(T[], Predicate<T>)	Określa, czy określona tablica zawiera elementy zgodne z warunkami zdefiniowanymi przez określony predykat.
Fill<T>(T[], T)	Przypisuje daną value typu T do każdego elementu określonego array.
Fill<T>(T[], T, Int32, Int32)	Przypisuje daną value typu T do elementów określonego array, które znajdują się w zakresie startIndex (włącznie) i następnej count liczby indeksów.
Find<T>(T[], Predicate<T>)	Wyszukuje element zgodny z warunkami zdefiniowanymi przez określony predykat i zwraca pierwsze wystąpienie w całym Array.
FindAll<T>(T[], Predicate<T>)	Pobiera wszystkie elementy zgodne z warunkami zdefiniowanymi przez określony predykat.
FindIndex<T>(T[], Int32, Int32, Predicate<T>)	Wyszukuje element zgodny z warunkami zdefiniowanymi przez określony predykat i zwraca indeks pierwszego wystąpienia w zakresie elementów w Array rozpoczynających się od określonego indeksu i zawiera określoną liczbę elementów.
FindIndex<T>(T[], Int32, Predicate<T>)	Wyszukuje element zgodny z warunkami zdefiniowanymi przez określony predykat i zwraca indeks pierwszego wystąpienia w zakresie elementów w Array, który rozciąga się od określonego indeksu do ostatniego elementu.
FindIndex<T>(T[], Predicate<T>)	Wyszukuje element zgodny z warunkami zdefiniowanymi przez określony predykat i zwraca indeks pierwszego wystąpienia w całym Array.
FindLast<T>(T[], Predicate<T>)	Wyszukuje element zgodny z warunkami zdefiniowanymi przez określony predykat i zwraca ostatnie wystąpienie w całym Array.
FindLastIndex<T>(T[], Int32, Int32, Predicate<T>)	Wyszukuje element zgodny z warunkami zdefiniowanymi przez określony predykat i zwraca indeks zera ostatniego wystąpienia w zakresie elementów w Array, który zawiera określoną liczbę elementów i kończy się na określonym indeksie.
FindLastIndex<T>(T[], Int32, Predicate<T>)	Wyszukuje element zgodny z warunkami zdefiniowanymi przez określony predykat i zwraca indeks zera ostatniego wystąpienia w zakresie elementów w Array, który rozciąga się od pierwszego elementu do określonego indeksu.
FindLastIndex<T>(T[], Predicate<T>)	Wyszukuje element zgodny z warunkami zdefiniowanymi przez określony predykat i zwraca indeks zerowy ostatniego wystąpienia w całym Array.
ForEach<T>(T[], Action<T>)	Wykonuje określoną akcję dla każdego elementu określonej tablicy.
GetEnumerator()	Zwraca IEnumerator dla Array.
GetHashCode()	Służy jako domyślna funkcja skrótu. (Odziedziczone po Object)
GetLength(Int32)	Pobiera 32-bitową liczbę całkowitą reprezentującą liczbę elementów w określonym wymiarze Array.
GetLongLength(Int32)	Pobiera 64-bitową liczbę całkowitą reprezentującą liczbę elementów w określonym wymiarze Array.
GetLowerBound(Int32)	Pobiera indeks pierwszego elementu określonego wymiaru w tablicy.
GetType()	Pobiera Type bieżącego wystąpienia. (Odziedziczone po Object)
GetUpperBound(Int32)	Pobiera indeks ostatniego elementu określonego wymiaru w tablicy.
GetValue(Int32)	Pobiera wartość na określonej pozycji w jednowymiarowej Array. Indeks jest określony jako 32-bitowa liczba całkowita.
GetValue(Int32, Int32)	Pobiera wartość na określonej pozycji w dwuwymiarowej Array. Indeksy są określane jako 32-bitowe liczby całkowite.
GetValue(Int32, Int32, Int32)	Pobiera wartość na określonej pozycji w trójwymiarowej Array. Indeksy są określane jako 32-bitowe liczby całkowite.
GetValue(Int32[])	Pobiera wartość na określonej pozycji w wielowymiarowym Array. Indeksy są określane jako tablica 32-bitowych liczb całkowitych.
GetValue(Int64)	Pobiera wartość na określonej pozycji w jednowymiarowej Array. Indeks jest określany jako 64-bitowa liczba całkowita.
GetValue(Int64, Int64)	Pobiera wartość na określonej pozycji w dwuwymiarowej Array. Indeksy są określane jako 64-bitowe liczby całkowite.
GetValue(Int64, Int64, Int64)	Pobiera wartość na określonej pozycji w trójwymiarowej Array. Indeksy są określane jako 64-bitowe liczby całkowite.
GetValue(Int64[])	Pobiera wartość na określonej pozycji w wielowymiarowym Array. Indeksy są określane jako tablica 64-bitowych liczb całkowitych.
IndexOf(Array, Object)	Wyszukuje określony obiekt i zwraca indeks pierwszego wystąpienia w tablicy jednowymiarowej.
IndexOf(Array, Object, Int32)	Wyszukuje określony obiekt w zakresie elementów jednowymiarowej tablicy i zwraca indeks pierwszego wystąpienia. Zakres rozciąga się od określonego indeksu na koniec tablicy.
IndexOf(Array, Object, Int32, Int32)	Wyszukuje określony obiekt w zakresie elementów tablicy jednowymiarowej i zwraca indeks ifs pierwszego wystąpienia. Zakres rozciąga się od określonego indeksu dla określonej liczby elementów.
IndexOf<T>(T[], T)	Wyszukuje określony obiekt i zwraca indeks pierwszego wystąpienia w tablicy jednowymiarowej.
IndexOf<T>(T[], T, Int32)	Wyszukuje określony obiekt w zakresie elementów jednowymiarowej tablicy i zwraca indeks pierwszego wystąpienia. Zakres rozciąga się od określonego indeksu na koniec tablicy.
IndexOf<T>(T[], T, Int32, Int32)	Wyszukuje określony obiekt w zakresie elementów jednowymiarowej tablicy i zwraca indeks pierwszego wystąpienia. Zakres rozciąga się od określonego indeksu dla określonej liczby elementów.
Initialize()	Inicjuje każdy element typu wartości Array przez wywołanie konstruktora bez parametrów typu wartości.
LastIndexOf(Array, Object)	Wyszukuje określony obiekt i zwraca indeks ostatniego wystąpienia w obrębie całej jednowymiarowej Array.
LastIndexOf(Array, Object, Int32)	Wyszukuje określony obiekt i zwraca indeks ostatniego wystąpienia w zakresie elementów w jednowymiarowej Array, która rozciąga się od pierwszego elementu do określonego indeksu.
LastIndexOf(Array, Object, Int32, Int32)	Wyszukuje określony obiekt i zwraca indeks ostatniego wystąpienia w zakresie elementów w jednowymiarowej Array zawierającej określoną liczbę elementów i kończy się na określonym indeksie.
LastIndexOf<T>(T[], T)	Wyszukuje określony obiekt i zwraca indeks ostatniego wystąpienia w całym Array.
LastIndexOf<T>(T[], T, Int32)	Wyszukuje określony obiekt i zwraca indeks ostatniego wystąpienia w zakresie elementów w Array, które rozciąga się od pierwszego elementu do określonego indeksu.
LastIndexOf<T>(T[], T, Int32, Int32)	Wyszukuje określony obiekt i zwraca indeks ostatniego wystąpienia w zakresie elementów w Array, który zawiera określoną liczbę elementów i kończy się na określonym indeksie.
MemberwiseClone()	Tworzy płytkią kopię bieżącego Object. (Odziedziczone po Object)
Resize<T>(T[], Int32)	Zmienia liczbę elementów tablicy jednowymiarowej na określony nowy rozmiar.
Reverse(Array)	Odwraca sekwencję elementów w całej jednowymiarowej Array.
Reverse(Array, Int32, Int32)	Odwraca sekwencję podzbioru elementów w jednowymiarowej Array.
Reverse<T>(T[])	Odwraca sekwencję elementów w jednowymiarowej tablicy ogólnej.
Reverse<T>(T[], Int32, Int32)	Odwraca sekwencję podzestawu elementów w jednowymiarowej tablicy ogólnej.
SetValue(Object, Int32)	Ustawia wartość elementu na określonej pozycji w jednowymiarowej Array. Indeks jest określony jako 32-bitowa liczba całkowita.
SetValue(Object, Int32, Int32)	Ustawia wartość elementu na określonej pozycji w dwuwymiarowej Array. Indeksy są określane jako 32-bitowe liczby całkowite.
SetValue(Object, Int32, Int32, Int32)	Ustawia wartość elementu na określonej pozycji w trójwymiarowej Array. Indeksy są określane jako 32-bitowe liczby całkowite.
SetValue(Object, Int32[])	Ustawia wartość elementu na określonej pozycji w wielowymiarowym Array. Indeksy są określane jako tablica 32-bitowych liczb całkowitych.
SetValue(Object, Int64)	Ustawia wartość elementu na określonej pozycji w jednowymiarowej Array. Indeks jest określany jako 64-bitowa liczba całkowita.
SetValue(Object, Int64, Int64)	Ustawia wartość elementu na określonej pozycji w dwuwymiarowej Array. Indeksy są określane jako 64-bitowe liczby całkowite.
SetValue(Object, Int64, Int64, Int64)	Ustawia wartość elementu na określonej pozycji w trójwymiarowej Array. Indeksy są określane jako 64-bitowe liczby całkowite.
SetValue(Object, Int64[])	Ustawia wartość elementu na określonej pozycji w wielowymiarowym Array. Indeksy są określane jako tablica 64-bitowych liczb całkowitych.
Sort(Array)	Sortuje elementy w całej jednowymiarowej Array przy użyciu implementacji IComparable każdego elementu Array.
Sort(Array, Array)	Sortuje parę jednowymiarowych obiektów Array (jeden zawiera klucze, a drugi zawiera odpowiednie elementy) na podstawie kluczy w pierwszym Array przy użyciu implementacji IComparable każdego klucza.
Sort(Array, Array, IComparer)	Sortuje parę jednowymiarowych obiektów Array (jeden zawiera klucze, a drugi zawiera odpowiednie elementy) na podstawie kluczy w pierwszym Array przy użyciu określonego IComparer.
Sort(Array, Array, Int32, Int32)	Sortuje szereg elementów w parze jednowymiarowych obiektów Array (jeden zawiera klucze, a drugi zawiera odpowiednie elementy) na podstawie kluczy w pierwszym Array przy użyciu IComparable implementacji każdego klucza.
Sort(Array, Array, Int32, Int32, IComparer)	Sortuje zakres elementów w parze jednowymiarowych obiektów Array (jeden zawiera klucze, a drugi zawiera odpowiednie elementy) na podstawie kluczy w pierwszym Array przy użyciu określonego IComparer.
Sort(Array, IComparer)	Sortuje elementy w jednowymiarowej Array przy użyciu określonego IComparer.
Sort(Array, Int32, Int32)	Sortuje elementy w zakresie elementów w jednowymiarowej Array przy użyciu implementacji IComparable każdego elementu Array.
Sort(Array, Int32, Int32, IComparer)	Sortuje elementy w zakresie elementów w jednowymiarowej Array przy użyciu określonego IComparer.
Sort<T>(T[])	Sortuje elementy w całej Array przy użyciu IComparable<T> implementacji interfejsu ogólnego każdego elementu Array.
Sort<T>(T[], Comparison<T>)	Sortuje elementy w Array przy użyciu określonego Comparison<T>.
Sort<T>(T[], IComparer<T>)	Sortuje elementy w Array przy użyciu określonego interfejsu ogólnego IComparer<T>.
Sort<T>(T[], Int32, Int32)	Sortuje elementy w zakresie elementów w Array przy użyciu IComparable<T> implementacji interfejsu ogólnego każdego elementu Array.
Sort<T>(T[], Int32, Int32, IComparer<T>)	Sortuje elementy w zakresie elementów w Array przy użyciu określonego interfejsu ogólnego IComparer<T>.
Sort<TKey,TValue>(TKey[], TValue[])	Sortuje parę obiektów Array (jeden zawiera klucze, a drugi zawiera odpowiednie elementy) na podstawie kluczy w pierwszym Array przy użyciu IComparable<T> implementacji interfejsu ogólnego każdego klucza.
Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>)	Sortuje parę obiektów Array (jeden zawiera klucze, a drugi zawiera odpowiednie elementy) na podstawie kluczy w pierwszym Array przy użyciu określonego interfejsu ogólnego IComparer<T>.
Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32)	Sortuje szereg elementów w parze obiektów Array (jeden zawiera klucze, a drugi zawiera odpowiednie elementy) na podstawie kluczy w pierwszym Array przy użyciu IComparable<T> implementacji interfejsu ogólnego każdego klucza.
Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>)	Sortuje zakres elementów w parze obiektów Array (jeden zawiera klucze, a drugi zawiera odpowiednie elementy) na podstawie kluczy w pierwszym Array przy użyciu określonego interfejsu ogólnego IComparer<T>.
ToString()	Zwraca ciąg reprezentujący bieżący obiekt. (Odziedziczone po Object)
TrueForAll<T>(T[], Predicate<T>)	Określa, czy każdy element w tablicy jest zgodny z warunkami zdefiniowanymi przez określony predykat.

Jawne implementacje interfejsu

ICollection.Count	Pobiera liczbę elementów zawartych w Array.
IList.Add(Object)	Wywołanie tej metody zawsze zgłasza wyjątek NotSupportedException.
IList.Clear()	Usuwa wszystkie elementy z IList.
IList.Contains(Object)	Określa, czy element znajduje się w IList.
IList.IndexOf(Object)	Określa indeks określonego elementu w IList.
IList.Insert(Int32, Object)	Wstawia element do IList w określonym indeksie.
IList.Item[Int32]	Pobiera lub ustawia element w określonym indeksie.
IList.Remove(Object)	Usuwa pierwsze wystąpienie określonego obiektu z IList.
IList.RemoveAt(Int32)	Usuwa element IList w określonym indeksie.
IStructuralComparable.CompareTo(Object, IComparer)	Określa, czy bieżący obiekt kolekcji poprzedza, występuje w tej samej pozycji co, czy następuje inny obiekt w kolejności sortowania.
IStructuralEquatable.Equals(Object, IEqualityComparer)	Określa, czy obiekt jest równy bieżącemu wystąpieniu.
IStructuralEquatable.GetHashCode(IEqualityComparer)	Zwraca kod skrótu dla bieżącego wystąpienia.

Metody rozszerzania

Cast<TResult>(IEnumerable)	Rzutuje elementy IEnumerable do określonego typu.
OfType<TResult>(IEnumerable)	Filtruje elementy IEnumerable na podstawie określonego typu.
AsParallel(IEnumerable)	Umożliwia równoległość zapytania.
AsQueryable(IEnumerable)	Konwertuje IEnumerable na IQueryable.

Bezpieczeństwo wątkowe

Publiczne statyczne (Shared w Visual Basic) składowe tego typu są bezpieczne wątkowo. Żadne elementy członkowskie wystąpienia nie mają gwarancji bezpieczeństwa wątków.

Ta implementacja nie zapewnia zsynchronizowanej (bezpiecznej wątkowej) otoki dla Array; jednak klasy .NET oparte na Array zapewniają własną zsynchronizowaną wersję kolekcji przy użyciu właściwości SyncRoot.

Wyliczanie za pośrednictwem kolekcji nie jest wewnętrznie procedurą bezpieczną wątkowo. Nawet w przypadku synchronizacji kolekcji inne wątki nadal mogą modyfikować kolekcję, co powoduje zgłoszenie wyjątku przez moduł wyliczający. Aby zagwarantować bezpieczeństwo wątków podczas wyliczania, możesz zablokować kolekcję podczas całego wyliczenia lub przechwycić wyjątki wynikające ze zmian wprowadzonych przez inne wątki.

Zobacz też

• Object
• Type
• wykonywanie operacji ciągów Culture-Insensitive w tablicach
• Tablice (Przewodnik programowania w języku C#)
• Tablice w języku F#
• tablice w języku Visual Basic