Array Sınıf

Tanım

Ad Alanı:

System

Bütünleştirilmiş Kod:

System.Runtime.dll

Kaynak:

Array.cs

Dizileri oluşturmak, işlemek, aramak ve sıralamak için yöntemler sağlar; böylece ortak dil çalışma zamanındaki tüm diziler için temel sınıf görevi görür.

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

Devralma

Object

Array

Uygulamalar

ICollection IEnumerable IList IStructuralComparable IStructuralEquatable ICloneable

Örnekler

Aşağıdaki kod örneği, Array.Copy öğesinin bir tamsayı türü dizisi ile Objecttüründeki bir dizi arasında öğeleri nasıl kopyalayıp kopyalayıp kopyalay gösterilmektedir.

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

Aşağıdaki kod örneği bir Array oluşturup başlatır ve özelliklerini ve öğelerini görüntüler.

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

Açıklamalar

Array sınıfı, System.Collections ad alanlarının bir parçası değildir. Ancak, IList arabirimini temel alan bir koleksiyon olarak kabul edilir.

Array sınıfı, dizileri destekleyen dil uygulamaları için temel sınıftır. Ancak, yalnızca sistem ve derleyiciler açıkça Array sınıfından türetilebilir. Kullanıcılar, dil tarafından sağlanan dizi yapılarını kullanmalıdır.

öğesi, Arrayiçindeki bir değerdir. bir Array uzunluğu içerebileceği toplam öğe sayısıdır. bir Array alt sınırı, ilk öğesinin dizinidir. bir Array herhangi bir alt sınıra sahip olabilir, ancak varsayılan olarak sıfır alt sınırına sahiptir. CreateInstancekullanarak Array sınıfının bir örneği oluşturulurken farklı bir alt sınır tanımlanabilir. Çok boyutlu bir Array her boyut için farklı sınırları olabilir. Bir dizi en fazla 32 boyuta sahip olabilir.

System.Collections ad alanlarının sınıflarından farklı olarak Array sabit bir kapasiteye sahiptir. Kapasiteyi artırmak için gerekli kapasiteye sahip yeni bir Array nesnesi oluşturmanız, eski Array nesnedeki öğeleri yenisine kopyalamanız ve eski Arraysilmeniz gerekir.

Dizi boyutu toplam 4 milyar öğeyle ve belirli bir boyuttaki en yüksek 0X7FEFFFFF diziniyle sınırlıdır (tek baytlı yapıların bayt dizileri ve dizileri için 0X7FFFFFC7).

Yalnızca .NET Framework : Varsayılan olarak, Array boyutu üst sınırı 2 gigabayttır (GB). 64 bitlik bir ortamda, gcAllowVeryLargeObjects yapılandırma öğesinin enabled özniteliğini çalışma zamanı ortamında true olarak ayarlayarak boyut kısıtlamasını önleyebilirsiniz.

Tek boyutlu diziler, System.Collections.Generic.IList<T>, System.Collections.Generic.ICollection<T>, System.Collections.Generic.IEnumerable<T>, System.Collections.Generic.IReadOnlyList<T> ve System.Collections.Generic.IReadOnlyCollection<T> genel arabirimleri uygular. Uygulamalar çalışma zamanında dizilere sağlanır ve sonuç olarak, genel arabirimler Array sınıfı için bildirim söz diziminde görünmez. Ayrıca, yalnızca bir diziyi genel arabirim türüne (açık arabirim uygulamaları) dönüştürerek erişilebilen arabirim üyeleri için başvuru konuları yoktur. Bir diziyi bu arabirimlerden birine dönüştürürken dikkat etmeniz gereken önemli nokta, öğeleri ekleyen, ekleyen veya kaldıran üyelerin NotSupportedExceptionoluşturmasıdır.

Type nesneleri dizi türü bildirimleri hakkında bilgi sağlar. Aynı dizi türüne sahip nesneleri Array aynı Type nesnesini paylaşır.

Type.IsArray ve Type.GetElementType beklenen sonuçları Array döndürmeyebilir çünkü dizi Arraytürüne yayınlanırsa sonuç bir dizi değil nesnedir. Başka bir typeof(System.Array).IsArrayfalsedöndürür ve typeof(System.Array).GetElementTypenulldöndürür.

Array.Copy yöntemi, öğeleri yalnızca aynı türdeki diziler arasında değil, aynı zamanda farklı türlerdeki standart diziler arasında da kopyalar; tür atamasını otomatik olarak işler.

CreateInstance, Copy, CopyTo, GetValueve SetValuegibi bazı yöntemler, büyük kapasite dizilerini barındırmak için parametre olarak 64 bit tamsayıları kabul eden aşırı yüklemeler sağlar. LongLength ve GetLongLength dizinin uzunluğunu gösteren 64 bit tamsayılar döndürür.

Array sıralanması garanti değildir. Array sıralanması gereken işlemleri (BinarySearchgibi) gerçekleştirmeden önce Array sıralamanız gerekir.

Yerel kodda işaretçilerin Array nesnesinin kullanılması desteklenmez ve çeşitli yöntemler için bir NotSupportedException oluşturur.

Özellikler

IsFixedSize	Array sabit bir boyuta sahip olup olmadığını gösteren bir değer alır.
IsReadOnly	Array salt okunur olup olmadığını gösteren bir değer alır.
IsSynchronized	Array erişimin eşitlenip eşitlenmediğini belirten bir değer alır (iş parçacığı güvenli).
Length	Arraytüm boyutlarındaki öğelerin toplam sayısını alır.
LongLength	Arraytüm boyutlarında öğelerin toplam sayısını temsil eden 64 bitlik bir tamsayı alır.
MaxLength	Bir dizide bulunabilecek en fazla öğe sayısını alır.
Rank	Arrayderecesini (boyut sayısı) alır. Örneğin, tek boyutlu bir dizi 1 döndürür, iki boyutlu bir dizi 2 döndürür ve bu şekilde devam eder.
SyncRoot	Arrayerişimini eşitlemek için kullanılabilecek bir nesnesi alır.

Yöntemler

AsReadOnly<T>(T[])	Belirtilen dizi için salt okunur sarmalayıcı döndürür.
BinarySearch(Array, Int32, Int32, Object)	Dizinin her öğesi tarafından ve belirtilen değere göre uygulanan IComparable arabirimini kullanarak bir değer için tek boyutlu sıralanmış dizideki bir öğe aralığını arar.
BinarySearch(Array, Int32, Int32, Object, IComparer)	Belirtilen IComparer arabirimini kullanarak bir değer için tek boyutlu sıralanmış dizideki bir öğe aralığını arar.
BinarySearch(Array, Object)	Dizinin her öğesi ve belirtilen nesne tarafından uygulanan IComparable arabirimini kullanarak tek boyutlu sıralanmış dizinin tamamını belirli bir öğe için arar.
BinarySearch(Array, Object, IComparer)	Belirtilen IComparer arabirimini kullanarak tek boyutlu sıralanmış dizinin tamamında bir değer arar.
BinarySearch<T>(T[], Int32, Int32, T)	Array her öğesi tarafından ve belirtilen değere göre uygulanan IComparable<T> genel arabirimini kullanarak bir değer için tek boyutlu sıralanmış dizideki bir öğe aralığını arar.
BinarySearch<T>(T[], Int32, Int32, T, IComparer<T>)	Belirtilen IComparer<T> genel arabirimini kullanarak bir değer için tek boyutlu sıralanmış dizideki bir öğe aralığını arar.
BinarySearch<T>(T[], T)	Array her öğesi tarafından ve belirtilen nesne tarafından uygulanan IComparable<T> genel arabirimini kullanarak tek boyutlu sıralanmış dizinin tamamını belirli bir öğe için arar.
BinarySearch<T>(T[], T, IComparer<T>)	Belirtilen IComparer<T> genel arabirimini kullanarak tek boyutlu sıralanmış dizinin tamamında bir değer arar.
Clear(Array)	Bir dizinin içeriğini temizler.
Clear(Array, Int32, Int32)	Bir dizideki öğe aralığını her öğe türünün varsayılan değerine ayarlar.
Clone()	Arraybasit bir kopyasını oluşturur.
ConstrainedCopy(Array, Int32, Array, Int32, Int32)	Belirtilen kaynak dizinde başlayan bir Array öğe aralığını kopyalar ve bunları belirtilen hedef dizinden başlayarak başka bir Array yapıştırır. Kopyalama tamamen başarılı olmazsa tüm değişikliklerin geri alındığını garanti eder.
ConvertAll<TInput,TOutput>(TInput[], Converter<TInput,TOutput>)	Bir tür dizisini başka türde bir diziye dönüştürür.
Copy(Array, Array, Int32)	İlk öğeden başlayarak bir Array öğe aralığını kopyalar ve ilk öğeden başlayarak başka bir Array yapıştırır. Uzunluk 32 bit tamsayı olarak belirtilir.
Copy(Array, Array, Int64)	İlk öğeden başlayarak bir Array öğe aralığını kopyalar ve ilk öğeden başlayarak başka bir Array yapıştırır. Uzunluk 64 bit tamsayı olarak belirtilir.
Copy(Array, Int32, Array, Int32, Int32)	Belirtilen kaynak dizinde başlayan bir Array öğe aralığını kopyalar ve bunları belirtilen hedef dizinden başlayarak başka bir Array yapıştırır. Uzunluk ve dizinler 32 bit tamsayılar olarak belirtilir.
Copy(Array, Int64, Array, Int64, Int64)	Belirtilen kaynak dizinde başlayan bir Array öğe aralığını kopyalar ve bunları belirtilen hedef dizinden başlayarak başka bir Array yapıştırır. Uzunluk ve dizinler 64 bit tamsayılar olarak belirtilir.
CopyTo(Array, Int32)	Geçerli tek boyutlu dizinin tüm öğelerini belirtilen hedef dizi dizininden başlayarak belirtilen tek boyutlu diziye kopyalar. Dizin 32 bit tamsayı olarak belirtilir.
CopyTo(Array, Int64)	Geçerli tek boyutlu dizinin tüm öğelerini belirtilen hedef dizi dizininden başlayarak belirtilen tek boyutlu diziye kopyalar. Dizin 64 bit tamsayı olarak belirtilir.
CreateInstance(Type, Int32)	Sıfır tabanlı dizin oluşturma ile belirtilen Type ve uzunluğun tek boyutlu bir Array oluşturur.
CreateInstance(Type, Int32, Int32)	Sıfır tabanlı dizin oluşturma ile belirtilen Type ve boyut uzunluklarının iki boyutlu bir Array oluşturur.
CreateInstance(Type, Int32, Int32, Int32)	Sıfır tabanlı dizinleme ile belirtilen Type ve boyut uzunluklarının üç boyutlu bir Array oluşturur.
CreateInstance(Type, Int32[])	Belirtilen Type ve boyut uzunluklarının çok boyutlu bir Array sıfır tabanlı dizin oluşturma ile oluşturur. Boyut uzunlukları 32 bit tamsayılar dizisinde belirtilir.
CreateInstance(Type, Int32[], Int32[])	Belirtilen alt sınırlarla belirtilen Type ve boyut uzunluklarının çok boyutlu bir Array oluşturur.
CreateInstance(Type, Int64[])	Belirtilen Type ve boyut uzunluklarının çok boyutlu bir Array sıfır tabanlı dizin oluşturma ile oluşturur. Boyut uzunlukları 64 bit tamsayılar dizisinde belirtilir.
Empty<T>()	Boş bir dizi döndürür.
Equals(Object)	Belirtilen nesnenin geçerli nesneye eşit olup olmadığını belirler. (Devralındığı yer: Object)
Exists<T>(T[], Predicate<T>)	Belirtilen dizinin, belirtilen koşul tarafından tanımlanan koşullarla eşleşen öğeler içerip içermediğini belirler.
Fill<T>(T[], T)	Belirtilen arrayher öğesine T türündeki verilen value atar.
Fill<T>(T[], T, Int32, Int32)	Belirtilen array öğelerine startIndex (dahil) ve sonraki count dizin sayısı içinde yer alan T türündeki belirli value atar.
Find<T>(T[], Predicate<T>)	Belirtilen koşul tarafından tanımlanan koşullarla eşleşen bir öğeyi arar ve tüm Arrayiçindeki ilk oluşumu döndürür.
FindAll<T>(T[], Predicate<T>)	Belirtilen koşul tarafından tanımlanan koşullarla eşleşen tüm öğeleri alır.
FindIndex<T>(T[], Int32, Int32, Predicate<T>)	Belirtilen koşul tarafından tanımlanan koşullarla eşleşen bir öğeyi arar ve belirtilen dizinde başlayan ve belirtilen öğe sayısını içeren Array öğe aralığındaki ilk oluşumun sıfır tabanlı dizinini döndürür.
FindIndex<T>(T[], Int32, Predicate<T>)	Belirtilen koşul tarafından tanımlanan koşullarla eşleşen bir öğeyi arar ve belirtilen dizinden son öğeye genişleten Array öğe aralığındaki ilk oluşumun sıfır tabanlı dizinini döndürür.
FindIndex<T>(T[], Predicate<T>)	Belirtilen koşul tarafından tanımlanan koşullarla eşleşen bir öğeyi arar ve tüm Arrayiçindeki ilk oluşumun sıfır tabanlı dizinini döndürür.
FindLast<T>(T[], Predicate<T>)	Belirtilen koşul tarafından tanımlanan koşullarla eşleşen bir öğeyi arar ve tüm Arrayiçinde son oluşumu döndürür.
FindLastIndex<T>(T[], Int32, Int32, Predicate<T>)	Belirtilen koşul tarafından tanımlanan koşullarla eşleşen bir öğeyi arar ve Array belirtilen öğe sayısını içeren ve belirtilen dizinde biten öğe aralığındaki son oluşumun sıfır tabanlı dizinini döndürür.
FindLastIndex<T>(T[], Int32, Predicate<T>)	Belirtilen koşul tarafından tanımlanan koşullarla eşleşen bir öğeyi arar ve ilk öğeden belirtilen dizine genişleten Array öğe aralığındaki son oluşumun sıfır tabanlı dizinini döndürür.
FindLastIndex<T>(T[], Predicate<T>)	Belirtilen koşul tarafından tanımlanan koşullarla eşleşen bir öğeyi arar ve tüm Arrayiçindeki son oluşumun sıfır tabanlı dizinini döndürür.
ForEach<T>(T[], Action<T>)	Belirtilen dizinin her öğesinde belirtilen eylemi gerçekleştirir.
GetEnumerator()	Arrayiçin bir IEnumerator döndürür.
GetHashCode()	Varsayılan karma işlevi işlevi görür. (Devralındığı yer: Object)
GetLength(Int32)	Arraybelirtilen boyuttaki öğe sayısını temsil eden 32 bitlik bir tamsayı alır.
GetLongLength(Int32)	Arraybelirtilen boyuttaki öğe sayısını temsil eden 64 bitlik bir tamsayı alır.
GetLowerBound(Int32)	Dizide belirtilen boyutun ilk öğesinin dizinini alır.
GetType()	Geçerli örneğin Type alır. (Devralındığı yer: Object)
GetUpperBound(Int32)	Dizide belirtilen boyutun son öğesinin dizinini alır.
GetValue(Int32)	Tek boyutlu Arraybelirtilen konumdaki değeri alır. Dizin 32 bit tamsayı olarak belirtilir.
GetValue(Int32, Int32)	İki boyutlu Arraybelirtilen konumdaki değeri alır. Dizinler 32 bit tamsayılar olarak belirtilir.
GetValue(Int32, Int32, Int32)	Üç boyutlu Arraybelirtilen konumdaki değeri alır. Dizinler 32 bit tamsayılar olarak belirtilir.
GetValue(Int32[])	Çok boyutlu Arraybelirtilen konumdaki değeri alır. Dizinler 32 bit tamsayılardan oluşan bir dizi olarak belirtilir.
GetValue(Int64)	Tek boyutlu Arraybelirtilen konumdaki değeri alır. Dizin 64 bit tamsayı olarak belirtilir.
GetValue(Int64, Int64)	İki boyutlu Arraybelirtilen konumdaki değeri alır. Dizinler 64 bit tamsayılar olarak belirtilir.
GetValue(Int64, Int64, Int64)	Üç boyutlu Arraybelirtilen konumdaki değeri alır. Dizinler 64 bit tamsayılar olarak belirtilir.
GetValue(Int64[])	Çok boyutlu Arraybelirtilen konumdaki değeri alır. Dizinler 64 bit tamsayılardan oluşan bir dizi olarak belirtilir.
IndexOf(Array, Object)	Belirtilen nesneyi arar ve tek boyutlu bir dizide ilk oluşumunun dizinini döndürür.
IndexOf(Array, Object, Int32)	Tek boyutlu bir dizinin öğe aralığında belirtilen nesneyi arar ve ilk oluşumunun dizinini döndürür. Aralık, belirtilen bir dizinden dizinin sonuna kadar uzanır.
IndexOf(Array, Object, Int32, Int32)	Tek boyutlu bir dizinin öğe aralığında belirtilen nesneyi arar ve ifs ilk oluşumunun dizinini döndürür. Aralık, belirtilen sayıda öğe için belirtilen dizinden genişletir.
IndexOf<T>(T[], T)	Belirtilen nesneyi arar ve tek boyutlu bir dizide ilk oluşumunun dizinini döndürür.
IndexOf<T>(T[], T, Int32)	Tek boyutlu bir dizinin öğe aralığında belirtilen nesneyi arar ve ilk oluşumunun dizinini döndürür. Aralık, belirtilen bir dizinden dizinin sonuna kadar uzanır.
IndexOf<T>(T[], T, Int32, Int32)	Tek boyutlu bir dizinin öğe aralığında belirtilen nesneyi arar ve ilk oluşumunun dizinini döndürür. Aralık, belirtilen sayıda öğe için belirtilen dizinden genişletir.
Initialize()	Değer türünün parametresiz oluşturucuyu çağırarak değer türü Array her öğesini başlatır.
LastIndexOf(Array, Object)	Belirtilen nesneyi arar ve tek boyutlu Arraytamamında son oluşumun dizinini döndürür.
LastIndexOf(Array, Object, Int32)	Belirtilen nesneyi arar ve ilk öğeden belirtilen dizine genişleten tek boyutlu Array öğe aralığındaki son oluşumun dizinini döndürür.
LastIndexOf(Array, Object, Int32, Int32)	Belirtilen nesneyi arar ve belirtilen öğe sayısını içeren ve belirtilen dizinde biten tek boyutlu Array öğe aralığındaki son oluşumun dizinini döndürür.
LastIndexOf<T>(T[], T)	Belirtilen nesneyi arar ve tüm Arrayiçindeki son oluşumun dizinini döndürür.
LastIndexOf<T>(T[], T, Int32)	Belirtilen nesneyi arar ve ilk öğeden belirtilen dizine genişleten Array öğe aralığındaki son oluşumun dizinini döndürür.
LastIndexOf<T>(T[], T, Int32, Int32)	Belirtilen nesneyi arar ve Array belirtilen öğe sayısını içeren ve belirtilen dizinde biten öğe aralığındaki son oluşumun dizinini döndürür.
MemberwiseClone()	Geçerli Objectbasit bir kopyasını oluşturur. (Devralındığı yer: Object)
Resize<T>(T[], Int32)	Tek boyutlu bir dizinin öğe sayısını belirtilen yeni boyuta değiştirir.
Reverse(Array)	tek boyutlu Arrayiçindeki öğelerin sırasını tersine çevirir.
Reverse(Array, Int32, Int32)	tek boyutlu Arrayöğelerin bir alt kümesinin sırasını tersine çevirir.
Reverse<T>(T[])	Tek boyutlu genel dizideki öğelerin sırasını tersine çevirir.
Reverse<T>(T[], Int32, Int32)	Tek boyutlu genel dizideki öğelerin bir alt kümesinin sırasını tersine çevirir.
SetValue(Object, Int32)	tek boyutlu Arraybelirtilen konumdaki öğesine bir değer ayarlar. Dizin 32 bit tamsayı olarak belirtilir.
SetValue(Object, Int32, Int32)	İki boyutlu Arraybelirtilen konumdaki öğesine bir değer ayarlar. Dizinler 32 bit tamsayılar olarak belirtilir.
SetValue(Object, Int32, Int32, Int32)	üç boyutlu Arraybelirtilen konumdaki öğesine bir değer ayarlar. Dizinler 32 bit tamsayılar olarak belirtilir.
SetValue(Object, Int32[])	çok boyutlu Arraybelirtilen konumdaki öğesine bir değer ayarlar. Dizinler 32 bit tamsayılardan oluşan bir dizi olarak belirtilir.
SetValue(Object, Int64)	tek boyutlu Arraybelirtilen konumdaki öğesine bir değer ayarlar. Dizin 64 bit tamsayı olarak belirtilir.
SetValue(Object, Int64, Int64)	İki boyutlu Arraybelirtilen konumdaki öğesine bir değer ayarlar. Dizinler 64 bit tamsayılar olarak belirtilir.
SetValue(Object, Int64, Int64, Int64)	üç boyutlu Arraybelirtilen konumdaki öğesine bir değer ayarlar. Dizinler 64 bit tamsayılar olarak belirtilir.
SetValue(Object, Int64[])	çok boyutlu Arraybelirtilen konumdaki öğesine bir değer ayarlar. Dizinler 64 bit tamsayılardan oluşan bir dizi olarak belirtilir.
Sort(Array)	Arrayher öğesinin IComparable uygulamasını kullanarak tek boyutlu Array içindeki öğeleri sıralar.
Sort(Array, Array)	Her anahtarın IComparable uygulamasını kullanarak ilk Array anahtarlara göre bir boyutlu Array nesne çiftini (biri anahtarları, diğeri de ilgili öğeleri içerir) sıralar.
Sort(Array, Array, IComparer)	Belirtilen IComparerkullanarak ilk Array anahtarlara göre bir boyutlu Array nesne çiftini (biri anahtarları, diğeri de ilgili öğeleri içerir) sıralar.
Sort(Array, Array, Int32, Int32)	Her bir anahtarın IComparable uygulamasını kullanarak ilk Array anahtarlara göre, bir boyutlu Array nesne çiftindeki bir öğe aralığını sıralar (biri anahtarları, diğeri de ilgili öğeleri içerir).
Sort(Array, Array, Int32, Int32, IComparer)	Bir öğe aralığını, belirtilen IComparerkullanan ilk Array anahtarlara göre bir boyutlu Array nesne çiftinde (biri anahtarları, diğeri de ilgili öğeleri içerir) sıralar.
Sort(Array, IComparer)	Belirtilen IComparerkullanarak öğeleri tek boyutlu bir Array sıralar.
Sort(Array, Int32, Int32)	Arrayher öğesinin IComparable uygulamasını kullanarak tek boyutlu bir Array içindeki öğe aralığındaki öğeleri sıralar.
Sort(Array, Int32, Int32, IComparer)	Belirtilen IComparerkullanarak tek boyutlu bir Array içindeki öğe aralığındaki öğeleri sıralar.
Sort<T>(T[])	Arrayher öğesinin IComparable<T> genel arabirim uygulamasını kullanarak tüm Array öğeleri sıralar.
Sort<T>(T[], Comparison<T>)	Belirtilen Comparison<T>kullanarak bir Array içindeki öğeleri sıralar.
Sort<T>(T[], IComparer<T>)	Belirtilen IComparer<T> genel arabirimini kullanarak bir Array içindeki öğeleri sıralar.
Sort<T>(T[], Int32, Int32)	Arrayher öğesinin IComparable<T> genel arabirim uygulamasını kullanarak bir Array içindeki öğe aralığındaki öğeleri sıralar.
Sort<T>(T[], Int32, Int32, IComparer<T>)	Belirtilen IComparer<T> genel arabirimini kullanarak bir Array öğe aralığındaki öğeleri sıralar.
Sort<TKey,TValue>(TKey[], TValue[])	Her anahtarın IComparable<T> genel arabirim uygulamasını kullanarak ilk Array anahtarlara göre bir çift Array nesnesi sıralar (biri anahtarları, diğeri de ilgili öğeleri içerir).
Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>)	Belirtilen IComparer<T> genel arabirimini kullanarak ilk Array anahtarlara göre bir çift Array nesnesi (biri anahtarları, diğeri de ilgili öğeleri içerir) sıralar.
Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32)	Her bir anahtarın IComparable<T> genel arabirim uygulamasını kullanarak ilk Array anahtarlara göre bir Array nesne çiftindeki bir öğe aralığını sıralar (biri anahtarları, diğeri de ilgili öğeleri içerir).
Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>)	Belirtilen IComparer<T> genel arabirimini kullanarak ilk Array anahtarlara göre, bir dizi öğeyi bir Array nesne çiftinde (biri anahtarları, diğeri de ilgili öğeleri içerir) sıralar.
ToString()	Geçerli nesneyi temsil eden bir dize döndürür. (Devralındığı yer: Object)
TrueForAll<T>(T[], Predicate<T>)	Dizideki her öğenin belirtilen koşul tarafından tanımlanan koşullarla eşleşip eşleşmediğini belirler.

Belirtik Arabirim Kullanımları

ICollection.Count	Arrayiçindeki öğe sayısını alır.
IList.Add(Object)	Bu yöntemin çağrılması her zaman bir NotSupportedException özel durumu oluşturur.
IList.Clear()	IListtüm öğeleri kaldırır.
IList.Contains(Object)	bir öğenin IListiçinde olup olmadığını belirler.
IList.IndexOf(Object)	IListbelirli bir öğenin dizinini belirler.
IList.Insert(Int32, Object)	Belirtilen dizinde IList bir öğe ekler.
IList.Item[Int32]	Belirtilen dizinde öğesini alır veya ayarlar.
IList.Remove(Object)	belirli bir nesnenin ilk oluşumunu IListkaldırır.
IList.RemoveAt(Int32)	Belirtilen dizindeki IList öğesini kaldırır.
IStructuralComparable.CompareTo(Object, IComparer)	Geçerli koleksiyon nesnesinin önce olup olmadığını, sıralama düzenindeki başka bir nesneyle aynı konumda mı gerçekleşeceğini veya başka bir nesneyi takip edip etmediğini belirler.
IStructuralEquatable.Equals(Object, IEqualityComparer)	Bir nesnenin geçerli örneğe eşit olup olmadığını belirler.
IStructuralEquatable.GetHashCode(IEqualityComparer)	Geçerli örnek için bir karma kodu döndürür.

Uzantı Metotları

Cast<TResult>(IEnumerable)	Bir IEnumerable öğelerini belirtilen türe yayınlar.
OfType<TResult>(IEnumerable)	Bir IEnumerable öğelerini belirtilen türe göre filtreler.
AsParallel(IEnumerable)	Sorgunun paralelleştirilmesini etkinleştirir.
AsQueryable(IEnumerable)	bir IEnumerableIQueryabledönüştürür.

İş Parçacığı Güvenliği

Bu türün genel statik (Visual Basic'teShared) üyeleri iş parçacığı güvenlidir. Hiçbir örnek üyesinin iş parçacığı güvenli olması garanti değildir.

Bu uygulama, bir Arrayiçin eşitlenmiş (iş parçacığı güvenli) sarmalayıcı sağlamaz; ancak, Array tabanlı .NET sınıfları, SyncRoot özelliğini kullanarak koleksiyonun kendi eşitlenmiş sürümünü sağlar.

Bir koleksiyonda numaralandırma, iş parçacığı açısından güvenli bir yordam değildir. Bir koleksiyon eşitlendiğinde bile, diğer iş parçacıkları yine de koleksiyonu değiştirebilir ve bu da numaralandırıcının bir özel durum oluşturmasına neden olur. Numaralandırma sırasında iş parçacığı güvenliğini garanti etmek için, tüm numaralandırma sırasında koleksiyonu kilitleyebilir veya diğer iş parçacıkları tarafından yapılan değişikliklerden kaynaklanan özel durumları yakalayabilirsiniz.

Ayrıca bkz.

• Object
• Type
• Dizilerde Culture-Insensitive Dize İşlemleri Gerçekleştirme
• Dizileri (C# Programlama Kılavuzu)
• F#'de Dizileri
• Visual Basic'da dizileri