Array Klasa

Definicja

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 : 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
Dziedziczenie
Array
Atrybuty
Implementuje

Przykłady

Poniższy przykład kodu pokazuje, jak Array.Copy kopiuje elementy między tablicą typu liczba całkowita a tablicą 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 element 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ą System.Collections przestrzeni nazw. Nadal jednak jest ona uznawana za kolekcję, 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 Array klasy. Użytkownicy powinni stosować konstrukcje tablic dostarczone przez język.

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

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

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 .NET Framework: domyślnie maksymalny rozmiar obiektu Array wynosi 2 gigabajty (GB). W środowisku 64-bitowym można uniknąć ograniczenia rozmiaru, ustawiając enabled atrybut elementu konfiguracji gcAllowVeryLargeObjects na true w środowisku czasu wykonywania.

Tablice jednowymiarowe implementują System.Collections.Generic.IList<T>interfejsy ogólne , System.Collections.Generic.ICollection<T>, System.Collections.Generic.IEnumerable<T>i System.Collections.Generic.IReadOnlyList<T>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 Array klasy. Ponadto nie ma tematów referencyjnych dla elementów członkowskich interfejsu, które są dostępne tylko przez rzutowanie tablicy do typu interfejsu ogólnego (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 usuńą elementy zgłaszają NotSupportedExceptionwartość .

Type obiekty zawierają informacje o deklaracjach typu tablicy. Array obiekty o tym samym typie tablicy współdzielą ten sam Type obiekt.

Type.IsArray i Type.GetElementType może nie zwracać oczekiwanych wyników z Array , ponieważ jeśli tablica jest rzutowanie do typu Array, wynik jest obiektem, a nie tablicą. Oznacza to, typeof(System.Array).IsArray że zwraca wartość false, i 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 rzutowanie typów automatycznie.

Niektóre metody, takie jak CreateInstance, , CopyToCopy, GetValuei SetValue, zapewniają przeciążenia, które akceptują 64-bitowe liczby całkowite jako parametry w celu obsługi dużych tablic pojemności. LongLength i GetLongLength zwracają 64-bitowe liczby całkowite wskazujące długość tablicy.

Nie Array ma gwarancji sortowania. Przed wykonaniem operacji (takich jak BinarySearch) należy sortowaćArray, które wymagają Array sortowania.

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

Właściwości

IsFixedSize

Pobiera wartość wskazującą, czy ma Array stały rozmiar.

IsReadOnly

Pobiera wartość wskazującą, czy kolekcja Array jest przeznaczona tylko do odczytu.

IsSynchronized

Pobiera wartość wskazującą, czy dostęp do elementu Array jest synchronizowany (bezpieczny wątk).

Length

Pobiera łączną liczbę elementów we wszystkich wymiarach obiektu 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) klasy Array. Na przykład jednowymiarowa tablica zwraca wartość 1, tablica dwuwymiarowa zwraca wartość 2 itd.

SyncRoot

Pobiera obiekt, który może służyć do synchronizowania dostępu do obiektu Array.

Metody

AsReadOnly<T>(T[])

Zwraca otokę tylko do odczytu dla określonej tablicy.

BinarySearch(Array, Int32, Int32, Object)

Wyszukuje zakres 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 IComparer interfejsu.

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 IComparer interfejsu.

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

Wyszukuje zakres elementów w jednowymiarowej tablicy posortowanej dla wartości przy użyciu interfejsu IComparable<T> ogólnego zaimplementowanego przez każdy element Array i przez określoną wartość.

BinarySearch<T>(T[], Int32, Int32, T, IComparer<T>)

Wyszukuje zakres elementów w jednowymiarowej tablicy posortowanej dla wartości przy użyciu określonego IComparer<T> interfejsu ogólnego.

BinarySearch<T>(T[], T)

Wyszukuje całą jednowymiarową tablicę posortowaną dla określonego elementu przy użyciu IComparable<T> interfejsu ogólnego zaimplementowanego przez każdy element Array obiektu i przez określony obiekt.

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

Wyszukuje całą jednowymiarową tablicę posortowaną dla wartości przy użyciu określonego IComparer<T> interfejsu ogólnego.

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ę obiektu Array.

ConstrainedCopy(Array, Int32, Array, Int32, Int32)

Kopiuje zakres elementów od określonego Array 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 od Array początku 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 od Array początku 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 zakres elementów od określonego Array 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 zakres elementów od określonego Array 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 jednowymiarowej tablicy 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 jednowymiarowej tablicy 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śloną Type i długość z indeksowaniem zerowym.

CreateInstance(Type, Int32, Int32)

Tworzy dwuwymiarową Array długość określonego Type wymiaru i z indeksowaniem zerowym.

CreateInstance(Type, Int32, Int32, Int32)

Tworzy trójwymiarową Array długość określonego Type wymiaru i z indeksowaniem zerowym.

CreateInstance(Type, Int32[])

Tworzy wielowymiarową Array długość określonego Type wymiaru i z indeksowaniem zerowym. Długości wymiarów są określane w tablicy 32-bitowych liczb całkowitych.

CreateInstance(Type, Int32[], Int32[])

Tworzy wielowymiarowe Array długości określonego Type i wymiarowego z określonymi dolnymi granicami.

CreateInstance(Type, Int64[])

Tworzy wielowymiarową Array długość określonego Type wymiaru i 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 dany obiekt jest taki sam, jak bieżący obiekt.

(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 dany value typ T do każdego elementu określonego arrayelementu .

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

Przypisuje dany value typ T do elementów określonych 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 Arrayobiekcie .

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 oparty na zerze pierwszego wystąpienia w zakresie elementów w Array obiekcie rozpoczynającym 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 oparty na zerze pierwszego wystąpienia w zakresie elementów w Array obiekcie, który rozciąga się od określonego indeksu do ostatniego elementu.

FindIndex<T>(T[], Predicate<T>)

Wyszukuje element, który pasuje do warunków zdefiniowanych przez określony predykat, i zwraca indeks zerowy pierwszego wystąpienia w całym Arrayobiekcie .

FindLast<T>(T[], Predicate<T>)

Wyszukuje element zgodny z warunkami zdefiniowanymi przez określony predykat i zwraca ostatnie wystąpienie w całym Arrayobiekcie .

FindLastIndex<T>(T[], Int32, Int32, Predicate<T>)

Wyszukuje element, który pasuje do warunków zdefiniowanych przez określony predykat, i zwraca indeks zerowy ostatniego wystąpienia w zakresie elementów w Array obiekcie zawierającym określoną liczbę elementów i kończy się na określonym indeksie.

FindLastIndex<T>(T[], Int32, Predicate<T>)

Wyszukuje element, który pasuje do warunków zdefiniowanych przez określony predykat, i zwraca indeks zerowy ostatniego wystąpienia w zakresie elementów w Array obiekcie, który rozciąga się od pierwszego elementu do określonego indeksu.

FindLastIndex<T>(T[], Predicate<T>)

Wyszukuje element, który pasuje do warunków zdefiniowanych przez określony predykat, i zwraca indeks zerowy ostatniego wystąpienia w całym Arrayobiekcie .

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

Wykonuje określoną akcję dla każdego elementu określonej tablicy.

GetEnumerator()

Zwraca wartość dla IEnumerator elementu 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ą, która reprezentuje liczbę elementów w określonym wymiarze .Array

GetLowerBound(Int32)

Pobiera indeks pierwszego elementu określonego wymiaru w tablicy.

GetType()

Type Pobiera bieżące wystąpienie.

(Odziedziczone po Object)
GetUpperBound(Int32)

Pobiera indeks ostatniego elementu określonego wymiaru w tablicy.

GetValue(Int32)

Pobiera wartość na określonej pozycji w jednowymiarowym Arrayobiekcie . Indeks jest określony jako 32-bitowa liczba całkowita.

GetValue(Int32, Int32)

Pobiera wartość na określonej pozycji w dwuwymiarowym Arrayobiekcie . Indeksy są określane jako 32-bitowe liczby całkowite.

GetValue(Int32, Int32, Int32)

Pobiera wartość na określonej pozycji w trójwymiarowym Arrayobiekcie . Indeksy są określane jako 32-bitowe liczby całkowite.

GetValue(Int32[])

Pobiera wartość na określonej pozycji w wielowymiarowym Arrayobiekcie . Indeksy są określane jako tablica 32-bitowych liczb całkowitych.

GetValue(Int64)

Pobiera wartość na określonej pozycji w jednowymiarowym Arrayobiekcie . Indeks jest określany jako 64-bitowa liczba całkowita.

GetValue(Int64, Int64)

Pobiera wartość na określonej pozycji w dwuwymiarowym Arrayobiekcie . Indeksy są określane jako 64-bitowe liczby całkowite.

GetValue(Int64, Int64, Int64)

Pobiera wartość na określonej pozycji w trójwymiarowym Arrayobiekcie . Indeksy są określane jako 64-bitowe liczby całkowite.

GetValue(Int64[])

Pobiera wartość na określonej pozycji w wielowymiarowym Arrayobiekcie . 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 do końca tablicy.

IndexOf(Array, Object, Int32, Int32)

Wyszukuje określony obiekt w zakresie elementów tablicy jednowymiarowej i zwraca indeks pierwszego wystąpienia ifs. 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 do końca 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 Array wartości 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łego jednowymiarowego Arrayobiektu .

LastIndexOf(Array, Object, Int32)

Wyszukuje określony obiekt i zwraca indeks ostatniego wystąpienia w zakresie elementów w jednowymiarowym Array , który 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 jednowymiarowym Array obiekcie zawierającym 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 Arrayobiekcie .

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

Wyszukuje określony obiekt i zwraca indeks ostatniego wystąpienia w zakresie elementów w obiekcie Array , który 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 obiekcie Array zawierającym określoną liczbę elementów i kończy się na określonym indeksie.

MemberwiseClone()

Tworzy płytkią kopię bieżącego Objectelementu .

(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łym jednowymiarowym Arrayobiekcie .

Reverse(Array, Int32, Int32)

Odwraca sekwencję podzestawu elementów w jednowymiarowym Arrayobiekcie .

Reverse<T>(T[])

Odwraca sekwencję elementów w jednowymiarowej tablicy ogólnej.

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

Odwraca sekwencję podzestawu elementów w tablicy ogólnej jednowymiarowej.

SetValue(Object, Int32)

Ustawia wartość elementu na określonej pozycji w jednowymiarowym Arrayobiekcie . Indeks jest określony jako 32-bitowa liczba całkowita.

SetValue(Object, Int32, Int32)

Ustawia wartość elementu na określonej pozycji w dwuwymiarowym Arrayobiekcie . Indeksy są określane jako 32-bitowe liczby całkowite.

SetValue(Object, Int32, Int32, Int32)

Ustawia wartość elementu na określonej pozycji w trójwymiarowym Arrayobiekcie . 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 jednowymiarowym Arrayobiekcie . Indeks jest określony jako 64-bitowa liczba całkowita.

SetValue(Object, Int64, Int64)

Ustawia wartość elementu na określonej pozycji w dwuwymiarowym Arrayobiekcie . Indeksy są określane jako 64-bitowe liczby całkowite.

SetValue(Object, Int64, Int64, Int64)

Ustawia wartość elementu na określonej pozycji w trójwymiarowym Arrayobiekcie . 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łości jednowymiarowej Array przy użyciu IComparable implementacji każdego elementu klasy Array.

Sort(Array, Array)

Sortuje parę obiektów jednowymiarowych Array (jeden zawiera klucze, a drugi zawiera odpowiednie elementy) na podstawie kluczy w pierwszej Array kolejności przy użyciu IComparable implementacji każdego klucza.

Sort(Array, Array, IComparer)

Sortuje parę obiektów jednowymiarowych Array (jeden zawiera klucze, a drugi zawiera odpowiednie elementy) na podstawie kluczy w pierwszym Array przy użyciu określonego IComparerelementu .

Sort(Array, Array, Int32, Int32)

Sortuje zakres elementów w parze jednowymiarowych Array obiektów (jeden zawiera klucze, a drugi zawiera odpowiednie elementy) na podstawie kluczy w pierwszej Array kolejności przy użyciu IComparable implementacji każdego klucza.

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

Sortuje zakres elementów w parze obiektów jednowymiarowych Array (jeden zawiera klucze, a drugi zawiera odpowiednie elementy) na podstawie kluczy w pierwszym Array przy użyciu określonego IComparerelementu .

Sort(Array, IComparer)

Sortuje elementy w jednowymiarowym Array formacie przy użyciu określonego IComparerelementu .

Sort(Array, Int32, Int32)

Sortuje elementy w zakresie elementów jednowymiarowych Array przy użyciu IComparable implementacji każdego elementu elementu Array.

Sort(Array, Int32, Int32, IComparer)

Sortuje elementy w zakresie elementów w jednowymiarowym Array przy użyciu określonego IComparerelementu .

Sort<T>(T[])

Sortuje elementy w całości Array przy użyciu IComparable<T> ogólnej implementacji interfejsu każdego elementu elementu Array.

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

Sortuje elementy w elemecie Array przy użyciu określonego Comparison<T>elementu .

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

Sortuje elementy za Array pomocą określonego IComparer<T> interfejsu ogólnego.

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

Sortuje elementy w wielu elementach przy Array użyciu IComparable<T> ogólnej implementacji interfejsu każdego elementu elementu Array.

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

Sortuje elementy w zakresie elementów w obiekcie Array przy użyciu określonego IComparer<T> interfejsu ogólnego.

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

Sortuje parę Array obiektów (jeden zawiera klucze, a drugi zawiera odpowiednie elementy) na podstawie kluczy w pierwszej Array kolejności przy użyciu IComparable<T> ogólnej implementacji interfejsu każdego klucza.

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

Sortuje parę Array obiektów (jeden zawiera klucze, a drugi zawiera odpowiednie elementy) na podstawie kluczy w pierwszym Array przy użyciu określonego IComparer<T> interfejsu ogólnego.

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

Sortuje zakres elementów w parze Array obiektów (jeden zawiera klucze, a drugi zawiera odpowiednie elementy) na podstawie kluczy w pierwszej Array kolejności przy użyciu IComparable<T> ogólnej implementacji interfejsu każdego klucza.

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

Sortuje zakres elementów w parze Array obiektów (jeden zawiera klucze, a drugi zawiera odpowiednie elementy) na podstawie kluczy w pierwszym Array przy użyciu określonego IComparer<T> interfejsu ogólnego.

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 słowniku Array.

ICollection.IsSynchronized

Pobiera wartość wskazującą, czy dostęp do elementu Array jest synchronizowany (bezpieczny wątek).

ICollection.SyncRoot

Pobiera obiekt, który może służyć do synchronizowania dostępu do obiektu Array.

IList.Add(Object)

Wywołanie tej metody zawsze zgłasza NotSupportedException wyjątek.

IList.Clear()

Usuwa wszystkie elementy z elementu IList.

IList.Contains(Object)

Określa, czy element znajduje się w elemecie IList.

IList.IndexOf(Object)

Określa indeks określonego elementu w elemencie IList.

IList.Insert(Int32, Object)

Wstawia element do IList określonego indeksu.

IList.IsFixedSize

Pobiera wartość wskazującą, czy ma Array stały rozmiar.

IList.IsReadOnly

Pobiera wartość wskazującą, czy jest tylko Array do odczytu.

IList.Item[Int32]

Pobiera lub ustawia element pod określonym indeksem.

IList.Remove(Object)

Usuwa pierwsze wystąpienie określonego obiektu z obiektu IList.

IList.RemoveAt(Int32)

IList Usuwa element w określonym indeksie.

IStructuralComparable.CompareTo(Object, IComparer)

Określa, czy bieżący obiekt kolekcji poprzedza, występuje w tej samej pozycji co 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 elementu IEnumerable na określony typ.

OfType<TResult>(IEnumerable)

Filtruje elementy elementu IEnumerable na podstawie określonego typu.

AsParallel(IEnumerable)

Umożliwia równoległość zapytania.

AsQueryable(IEnumerable)

Konwertuje element IEnumerable na .IQueryable

Dotyczy

Bezpieczeństwo wątkowe

Publiczne statyczne (Shared w Visual Basic) elementy członkowskie tego typu są bezpieczne wątkami. Wystąpienia elementów członkowskich nie dają gwarancji bezpieczeństwa wątków.

Ta implementacja nie zapewnia zsynchronizowanej (bezpiecznej wątku) otoki dla klasy Array. Jednak klasy platformy .NET oparte na Array udostępnieniu własnej zsynchronizowanej wersji kolekcji przy użyciu SyncRoot właściwości .

Wyliczanie w kolekcji nie jest wewnętrznie procedurą odporną na wielowątkowość. Nawet gdy kolekcja jest synchronizowana, inne wątki nadal mogą ją modyfikować. Powoduje to zgłaszanie wyjątku przez moduł wyliczający. Aby zagwarantować bezpieczeństwo wątków podczas wyliczania, można zablokować kolekcję podczas całego procesu wyliczania albo rejestrować wyjątki wynikłe ze zmian wprowadzanych przez inne wątków.

Zobacz też