Array Sınıf

Tanım

Ortak dil çalışma zamanındaki tüm diziler için temel sınıf olarak hizmet veren dizi oluşturma, işleme, arama ve sıralama yöntemleri sağlar.

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
Devralma
Array
Öznitelikler
Uygulamalar

Örnekler

Aşağıdaki kod örneği, bir tamsayı türü dizisi ile türündeki bir dizi arasında öğelerin nasıl Array.Copy kopyalanıp kopyalanmasını Objectgösterir.

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şturur ve 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ı ad alanlarının System.Collections bir parçası değildir. Ancak, arabirimini temel alan IList 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 sınıfından Array türetilebilir. Kullanıcılar, dil tarafından sağlanan dizi yapılarını kullanmalıdır.

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

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

Dizi boyutu toplam 4 milyar öğeyle ve herhangi bir boyuttaki en fazla 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, en Array büyük boyut 2 gigabayttır (GB). 64 bitlik bir ortamda, çalışma zamanı ortamında gcAllowVeryLargeObjects yapılandırma öğesinin özniteliğini olarak true ayarlayarak enabled boyut kısıtlamasını önleyebilirsiniz.

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

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

Type.IsArray ve Type.GetElementType ile beklenen sonuçları Array döndürmeyebilir çünkü bir dizi türüne Arrayyayınlanırsa sonuç bir dizi değil bir nesnedir. Yani, typeof(System.Array).IsArray döndürür falseve typeof(System.Array).GetElementType döndürür null.

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 atamayı otomatik olarak işler.

, GetValueCopyCopyTo, , ve SetValuegibi CreateInstancebazı 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 belirten 64 bit tamsayılar döndürür.

öğesinin Array sıralanması garanti değildir. sıralamasını Array gerektiren işlemleri (örneğin BinarySearch) gerçekleştirmeden önce öğesini Array sıralamanız gerekir.

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

Özellikler

IsFixedSize

değerinin sabit bir boyuta sahip olup olmadığını Array belirten bir değer alır.

IsReadOnly

Array öğesinin salt okunur olup olmadığını belirten bir değer alır.

IsSynchronized

erişimin Array eşitlenip eşitlenmediğini belirten bir değer alır (iş parçacığı güvenli).

Length

öğesinin tüm boyutlarındaki Arrayöğelerin toplam sayısını alır.

LongLength

öğesinin tüm boyutlarındaki öğelerin toplam sayısını temsil eden 64 bitlik bir tamsayı Arrayalır.

MaxLength

Bir dizide bulunabilecek en fazla öğe sayısını alır.

Rank

öğesinin derecesini (boyut sayısı) Arrayalır. Örneğin, tek boyutlu bir dizi 1 döndürür, iki boyutlu dizi 2 döndürür ve bu şekilde devam eder.

SyncRoot

erişimi Arrayeş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 arabirimini kullanarak IComparable tek boyutlu bir sıralanmış dizideki öğe aralığını bir değer için arar.

BinarySearch(Array, Int32, Int32, Object, IComparer)

Belirtilen IComparer arabirimi kullanarak bir değer için tek boyutlu bir sıralanmış dizideki öğe aralığını arar.

BinarySearch(Array, Object)

Dizinin her öğesi ve belirtilen nesne tarafından uygulanan arabirimini kullanarak IComparable tek boyutlu sıralanmış dizinin tamamını belirli bir öğe için arar.

BinarySearch(Array, Object, IComparer)

Belirtilen IComparer arabirimi kullanarak bir değer için tek boyutlu sıralanmış dizinin tamamını arar.

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

ve öğelerinin her biri tarafından belirtilen değere göre uygulanan genel arabirimi kullanarak IComparable<T> bir değer için tek boyutlu sıralanmış dizideki Array bir öğe aralığını arar.

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

Belirtilen IComparer<T> genel arabirimi kullanarak bir değer için tek boyutlu sıralanmış dizideki bir öğe aralığını arar.

BinarySearch<T>(T[], T)

ve öğesinin her öğesi tarafından belirtilen nesne tarafından uygulanan genel arabirimi kullanarak IComparable<T> tek boyutlu sıralanmış dizinin tamamını belirli bir öğe Array için arar.

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

Belirtilen IComparer<T> genel arabirimi kullanarak tek boyutlu bir 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()

öğesinin Arraysığ bir kopyasını oluşturur.

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

Belirtilen kaynak dizinden başlayan bir Array öğe aralığını kopyalar ve bunları belirtilen hedef dizinden başlayarak başka bir Array öğeye yapıştırır. Kopya 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 öğedeki bir başlangıç öğesinden bir Array öğe aralığını kopyalar ve bunları ilk öğeden başlayarak başka bir Array öğeye yapıştırır. Uzunluk 32 bitlik bir tamsayı olarak belirtilir.

Copy(Array, Array, Int64)

İlk öğedeki bir başlangıç öğesinden bir Array öğe aralığını kopyalar ve bunları ilk öğeden başlayarak başka bir Array öğeye yapıştırır. Uzunluk 64 bitlik bir tamsayı olarak belirtilir.

Copy(Array, Int32, Array, Int32, Int32)

Belirtilen kaynak dizinden başlayan bir Array öğe aralığını kopyalar ve bunları belirtilen hedef dizinden başlayarak başka bir Array öğeye yapıştırır. Uzunluk ve dizinler 32 bit tamsayılar olarak belirtilir.

Copy(Array, Int64, Array, Int64, Int64)

Belirtilen kaynak dizinden başlayan bir Array öğe aralığını kopyalar ve bunları belirtilen hedef dizinden başlayarak başka bir Array öğeye 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ğunun tek boyutlu Array bir öğesini oluşturur.

CreateInstance(Type, Int32, Int32)

Sıfır tabanlı dizinleme ile belirtilen Type ve boyut uzunluklarının iki boyutlu Array bir öğesini oluşturur.

CreateInstance(Type, Int32, Int32, Int32)

Sıfır tabanlı dizinleme ile belirtilen Type ve boyut uzunluklarının üç boyutlu Array bir öğesini oluşturur.

CreateInstance(Type, Int32[])

Belirtilen Type ve boyut uzunluklarının çok boyutlu Array bir kısmını sıfır tabanlı dizinleme 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 Array bir öğesini oluşturur.

CreateInstance(Type, Int64[])

Belirtilen Type ve boyut uzunluklarının çok boyutlu Array bir kısmını sıfır tabanlı dizinleme 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 arrayöğesinin her öğesine verilen value türü T atar.

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

Belirtilen value türü, belirtilen array (dahil) ve sonraki count dizin sayısı aralığındaki startIndex T öğelerine atar.

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

Belirtilen koşul tarafından tanımlanan koşullarla eşleşen bir öğeyi arar ve içindeki ilk oluşumu döndürür Array.

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 içinde belirtilen dizinde başlayan ve belirtilen sayıda öğeyi içeren öğe Array 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 öğesindeki belirtilen dizinden son öğeye kadar uzanan öğe Array 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 içindeki son oluşumu döndürür Array.

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

Belirtilen koşul tarafından tanımlanan koşullarla eşleşen bir öğeyi arar ve öğesinde Array belirtilen sayıda öğe 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 içindeki ilk öğeden belirtilen dizine kadar uzanan öğe Array 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 içindeki Arrayson 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()

için Arraybir IEnumerator döndürür.

GetHashCode()

Varsayılan karma işlevi işlevi görür.

(Devralındığı yer: Object)
GetLength(Int32)

öğesinin belirtilen boyutundaki Arrayöğelerin sayısını temsil eden 32 bitlik bir tamsayı alır.

GetLongLength(Int32)

öğesinin belirtilen boyutundaki Arrayöğelerin sayısını temsil eden 64 bitlik bir tamsayı alır.

GetLowerBound(Int32)

Dizide belirtilen boyutun ilk öğesinin dizinini alır.

GetType()

Type Geçerli örneğini alır.

(Devralındığı yer: Object)
GetUpperBound(Int32)

Dizide belirtilen boyutun son öğesinin dizinini alır.

GetValue(Int32)

Değeri tek boyutlu Arrayiçinde belirtilen konumda alır. Dizin 32 bitlik bir tamsayı olarak belirtilir.

GetValue(Int32, Int32)

İki boyutlu Arrayiçinde belirtilen konumdaki değeri alır. Dizinler, 32 bit tamsayılar olarak belirtilir.

GetValue(Int32, Int32, Int32)

Değeri üç boyutlu Arrayiçinde belirtilen konumda alır. Dizinler, 32 bit tamsayılar olarak belirtilir.

GetValue(Int32[])

Çok boyutlu Arrayiçinde belirtilen konumdaki değeri alır. Dizinler 32 bitlik tamsayı dizisi olarak belirtilir.

GetValue(Int64)

Değeri tek boyutlu Arrayiçinde belirtilen konumda alır. Dizin 64 bit tamsayı olarak belirtilir.

GetValue(Int64, Int64)

İki boyutlu Arrayiçinde belirtilen konumdaki değeri alır. Dizinler 64 bit tamsayılar olarak belirtilir.

GetValue(Int64, Int64, Int64)

Değeri üç boyutlu Arrayiçinde belirtilen konumda alır. Dizinler 64 bit tamsayılar olarak belirtilir.

GetValue(Int64[])

Çok boyutlu Arrayiçinde belirtilen konumdaki değeri alır. Dizinler 64 bitlik 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 first occurrence dizinini döndürür. Aralık, belirtilen sayıda öğe için belirtilen dizinden genişletildi.

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şletildi.

Initialize()

Değer türünün parametresiz oluşturucuyu çağırarak değer türünün Array her öğesini başlatır.

LastIndexOf(Array, Object)

Belirtilen nesneyi arar ve tek boyutlu Arrayöğesinin tamamı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 öğeler aralığındaki son oluşumun dizinini döndürür.

LastIndexOf(Array, Object, Int32, Int32)

Belirtilen nesneyi arar ve belirtilen sayıda öğe içeren ve belirtilen dizinde biten tek boyutlu Array öğeler 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 içindeki ilk öğeden belirtilen dizine genişleten öğe aralığındaki Array son oluşumun dizinini döndürür.

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

Belirtilen nesneyi arar ve öğesinde belirtilen sayıda öğe içeren ve belirtilen dizinde biten öğe aralığındaki Array son oluşumun dizinini döndürür.

MemberwiseClone()

Geçerli Objectöğesinin sığ 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)

Tüm tek boyutlu Arrayiçindeki öğelerin sırasını tersine çevirir.

Reverse(Array, Int32, Int32)

Tek boyutlu Arrayiçindeki öğ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)

Bir değeri, tek boyutlu Arrayöğesinde belirtilen konumdaki öğesine ayarlar. Dizin 32 bit tamsayı olarak belirtilir.

SetValue(Object, Int32, Int32)

öğesine iki boyutlu Arrayiçinde belirtilen konumda bir değer ayarlar. Dizinler, 32 bit tamsayılar olarak belirtilir.

SetValue(Object, Int32, Int32, Int32)

Üç boyutlu Arrayöğesinde belirtilen konumdaki öğesine bir değer ayarlar. Dizinler, 32 bit tamsayılar olarak belirtilir.

SetValue(Object, Int32[])

çok boyutlu Arrayöğesinde belirtilen konumdaki öğesine bir değer ayarlar. Dizinler 32 bit tamsayı dizisi olarak belirtilir.

SetValue(Object, Int64)

bir değerini, tek boyutlu Arrayöğesinde belirtilen konumdaki öğesine ayarlar. Dizin 64 bit tamsayı olarak belirtilir.

SetValue(Object, Int64, Int64)

öğesine iki boyutlu Arrayiçinde belirtilen konumda bir değer ayarlar. Dizinler 64 bit tamsayılar olarak belirtilir.

SetValue(Object, Int64, Int64, Int64)

Üç boyutlu Arrayöğesinde belirtilen konumdaki öğesine bir değer ayarlar. Dizinler 64 bit tamsayılar olarak belirtilir.

SetValue(Object, Int64[])

Öğeye çok boyutlu Arrayiçinde belirtilen konumda bir değer ayarlar. Dizinler 64 bitlik tamsayılardan oluşan bir dizi olarak belirtilir.

Sort(Array)

öğesinin her öğesinin IComparable Arrayuygulamasını kullanarak tek boyutlu Array öğelerin tamamını sıralar.

Sort(Array, Array)

Bir boyutlu Array nesne çiftini (biri anahtarları, diğeri de ilgili öğeleri içerir) her anahtarın uygulamasını kullanan IComparable ilk Array anahtarlara göre sıralar.

Sort(Array, Array, IComparer)

Bir boyutlu Array nesne çiftini (biri anahtarları, diğeri ise ilgili öğeleri içerir) belirtilen ICompareröğesini kullanan ilk Array içindeki anahtarlara göre sıralar.

Sort(Array, Array, Int32, Int32)

Bir dizi öğeyi bir çift boyutlu Array nesnede (biri anahtarları, diğeri de karşılık gelen öğeleri içerir) her anahtarın uygulamasını kullanan IComparable ilk Array anahtarlara göre sıralar.

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

Belirtilen ICompareröğesini kullanan ilk Array öğedeki anahtarlara göre, bir öğe aralığını bir çift boyutlu Array nesnede (biri anahtarları, diğeri de ilgili öğeleri içerir) sıralar.

Sort(Array, IComparer)

Belirtilen ICompareröğesini kullanarak öğeleri tek boyutlu Array olarak sıralar.

Sort(Array, Int32, Int32)

öğesinin her öğesinin uygulamasını kullanarak IComparable bir öğe aralığındaki öğeleri Arraytek boyutlu Array olarak sıralar.

Sort(Array, Int32, Int32, IComparer)

Belirtilen ICompareröğesini kullanarak tek boyutlu Array bir öğe aralığındaki öğeleri sıralar.

Sort<T>(T[])

öğesinin her öğesinin IComparable<T> genel arabirim uygulamasını kullanarak bir bütündeki Array öğeleri Arraysıralar.

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

belirtilen Comparison<T>öğesini kullanarak içindeki Array öğeleri sıralar.

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

Belirtilen IComparer<T> genel arabirimi kullanarak içindeki Array öğeleri sıralar.

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

öğesinin her öğesinin genel arabirim uygulamasını kullanarak IComparable<T> içindeki bir Array öğe aralığındaki Arrayöğeleri sıralar.

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

Belirtilen IComparer<T> genel arabirimi kullanarak içindeki Array bir öğe aralığındaki öğeleri sıralar.

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

Bir nesne çiftini Array (biri anahtarları, diğeri de ilgili öğeleri içerir) her anahtarın genel arabirim uygulamasını kullanarak IComparable<T> ilk Array anahtarlara göre sıralar.

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

Belirtilen IComparer<T> genel arabirimi kullanan ilk Array nesnedeki Array anahtarlara göre bir nesne çiftini (biri anahtarları, diğeri de ilgili öğeleri içerir) sıralar.

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

Her bir anahtarın genel arabirim uygulamasını kullanarak IComparable<T> bir nesne çiftindeki Array bir öğe aralığını (biri anahtarları, diğeri de ilgili öğeleri içerir) ilkindeki Array anahtarlara göre sıralar.

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

Belirtilen IComparer<T> genel arabirimi kullanan ilk Array öğedeki anahtarlara göre, bir nesne çiftindeki Array bir öğe aralığını sıralar (biri anahtarları, diğeri de ilgili öğeleri içerir).

ToString()

Geçerli nesneyi temsil eden dizeyi 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

Array içindeki öğe sayısını alır.

ICollection.IsSynchronized

erişimin Array eşitlenip eşitlenmediğini belirten bir değer alır (iş parçacığı güvenli).

ICollection.SyncRoot

erişimi Arrayeşitlemek için kullanılabilecek bir nesnesi alır.

IList.Add(Object)

Bu yöntemin çağrılması her zaman bir NotSupportedException özel durum oluşturur.

IList.Clear()

öğesinden IListtüm öğeleri kaldırır.

IList.Contains(Object)

Bir öğenin içinde IListolup olmadığını belirler.

IList.IndexOf(Object)

içindeki belirli bir öğenin dizinini IListbelirler.

IList.Insert(Int32, Object)

Belirtilen dizinde öğesine IList bir öğe ekler.

IList.IsFixedSize

değerinin sabit bir boyuta sahip olup olmadığını Array belirten bir değer alır.

IList.IsReadOnly

öğesinin salt okunur olup olmadığını Array gösteren bir değer alır.

IList.Item[Int32]

Belirtilen dizindeki öğeyi alır veya ayarlar.

IList.Remove(Object)

belirli bir nesnenin ilk oluşumunu öğesinden IListkaldırır.

IList.RemoveAt(Int32)

Belirtilen dizindeki IList öğeyi 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ı yoksa takip mi olduğunu 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)

öğesinin IEnumerable öğelerini belirtilen türe atar.

OfType<TResult>(IEnumerable)

Bir öğesinin IEnumerable öğelerini belirtilen türe göre filtreler.

AsParallel(IEnumerable)

Sorgunun paralelleştirilmesini sağlar.

AsQueryable(IEnumerable)

bir IEnumerable öğesini öğesine IQueryabledönüştürür.

Şunlara uygulanır

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

Bu türün genel statik (SharedVisual Basic) üyeleri iş parçacığı güvenlidir. Örnek üyelerin iş parçacığı güvenli olmaları garanti edilmez.

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

Bir koleksiyon ile numaralandırma, aslında iş parçacığı açısından güvenli yordam değildir. Bir koleksiyon eşitlendiği zaman bile, diğer iş parçacıkları numaralandırıcının özel durum oluşturmasına neden olan koleksiyonu değiştirebilir. Numaralandırma sırasında iş parçacığı güvenliği sağlamak 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.