Array Klasse

Definition

Namespace:

System

Assembly:

System.Runtime.dll

Quelle:

Array.cs

Stellt Methoden zum Erstellen, Bearbeiten, Durchsuchen und Sortieren von Arrays bereit, die somit als Basisklasse für alle Arrays in der Common Language Runtime dienen.

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

Vererbung

Object

Array

Implementiert

ICollection IEnumerable IList IStructuralComparable IStructuralEquatable ICloneable

Beispiele

Das folgende Codebeispiel zeigt, wie Array.Copy Elemente zwischen einem Array vom Typ "integer" und einem Array vom Typ "Object" kopiert.

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

Im folgenden Codebeispiel wird ein Array erstellt und initialisiert und seine Eigenschaften und die zugehörigen Elemente angezeigt.

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

Hinweise

Die Array-Klasse ist nicht Teil der System.Collections Namespaces. Es wird jedoch immer noch als Sammlung betrachtet, da sie auf der IList Schnittstelle basiert.

Die Array Klasse ist die Basisklasse für Sprachimplementierungen, die Arrays unterstützen. Allerdings können nur das System und die Compiler explizit von der Array-Klasse abgeleitet werden. Benutzer sollten die Arraykonstrukte verwenden, die von der Sprache bereitgestellt werden.

Ein Element ist ein Wert in einem Array. Die Länge eines Array ist die Gesamtanzahl der Darin enthaltenen Elemente. Die untere Grenze eines Array ist der Index des ersten Elements. Ein Array kann eine beliebige untere Grenze aufweisen, hat jedoch standardmäßig eine untere Grenze von Null. Eine andere untere Grenze kann beim Erstellen einer Instanz der Array Klasse mithilfe von CreateInstancedefiniert werden. Eine multidimensionale Array kann für jede Dimension unterschiedliche Grenzen aufweisen. Ein Array kann maximal 32 Dimensionen aufweisen.

Im Gegensatz zu den Klassen in den System.Collections Namespaces verfügt Array über eine feste Kapazität. Um die Kapazität zu erhöhen, müssen Sie ein neues Array-Objekt mit der erforderlichen Kapazität erstellen, die Elemente aus dem alten Array-Objekt in das neue kopieren und die alte Arraylöschen.

Die Arraygröße ist auf insgesamt 4 Milliarden Elemente beschränkt und auf einen maximalen Index von 0X7FEFFFFF in jeder bestimmten Dimension (0X7FFFFFC7 für Bytearrays und Arrays von Einzelbytestrukturen).

.NET Framework: Standardmäßig beträgt die maximale Größe eines Array 2 Gigabyte (GB). In einer 64-Bit-Umgebung können Sie die Größenbeschränkung vermeiden, indem Sie das enabled Attribut des gcAllowVeryLargeObjects Konfigurationselements auf true in der Laufzeitumgebung festlegen.

Eindimensionale Arrays implementieren die System.Collections.Generic.IList<T>, System.Collections.Generic.ICollection<T>, System.Collections.Generic.IEnumerable<T>, System.Collections.Generic.IReadOnlyList<T> und System.Collections.Generic.IReadOnlyCollection<T> generischen Schnittstellen. Die Implementierungen werden zur Laufzeit für Arrays bereitgestellt, und daher werden die generischen Schnittstellen nicht in der Deklarationssyntax für die Array Klasse angezeigt. Darüber hinaus gibt es keine Referenzthemen für Schnittstellenmber, auf die nur durch Umwandlung eines Arrays in den generischen Schnittstellentyp (explizite Schnittstellenimplementierungen) zugegriffen werden kann. Das Wichtigste, was Sie beachten müssen, wenn Sie ein Array in eine dieser Schnittstellen umwandeln, besteht darin, dass Elemente, die Elemente hinzufügen, einfügen oder entfernen, NotSupportedExceptionauslösen.

Type Objekte stellen Informationen zu Arraytypdeklarationen bereit. Array Objekte mit demselben Arraytyp verwenden dasselbe Type Objekt.

Type.IsArray und Type.GetElementType geben möglicherweise nicht die erwarteten Ergebnisse mit Array zurück, da das Ergebnis ein Objekt und kein Array ist, wenn ein Array in den Typ Arraygegossen wird. Das heißt, typeof(System.Array).IsArray gibt falsezurück, und typeof(System.Array).GetElementType gibt nullzurück.

Die Array.Copy Methode kopiert Elemente nicht nur zwischen Arrays desselben Typs, sondern auch zwischen Standardarrays unterschiedlicher Typen; es behandelt die Typwandlung automatisch.

Einige Methoden, z. B. CreateInstance, Copy, CopyTo, GetValueund SetValue, stellen Überladungen bereit, die 64-Bit-Ganzzahlen als Parameter akzeptieren, um Arrays mit großer Kapazität aufzunehmen. LongLength und GetLongLength 64-Bit-Ganzzahlen zurückgeben, die die Länge des Arrays angeben.

Die Array ist nicht garantiert sortiert. Sie müssen die Array vor dem Ausführen von Vorgängen (z. B. BinarySearch) sortieren, für die die Array sortiert werden müssen.

Die Verwendung eines Array Objekts von Zeigern im systemeigenen Code wird nicht unterstützt und löst eine NotSupportedException für mehrere Methoden aus.

Eigenschaften

IsFixedSize	Ruft einen Wert ab, der angibt, ob die Array eine feste Größe aufweist.
IsReadOnly	Ruft einen Wert ab, der angibt, ob die Array schreibgeschützt ist.
IsSynchronized	Ruft einen Wert ab, der angibt, ob der Zugriff auf die Array synchronisiert wird (Threadsicher).
Length	Ruft die Gesamtanzahl der Elemente in allen Dimensionen der Arrayab.
LongLength	Ruft eine 64-Bit-Ganzzahl, die die Gesamtanzahl der Elemente in allen Dimensionen der Arraydarstellt.
MaxLength	Ruft die maximale Anzahl von Elementen ab, die in einem Array enthalten sein können.
Rank	Ruft den Rang (Anzahl der Dimensionen) des Arrayab. Ein eindimensionales Array gibt z. B. 1 zurück, ein zweidimensionales Array gibt "2" zurück usw.
SyncRoot	Ruft ein Objekt ab, das zum Synchronisieren des Zugriffs auf die Arrayverwendet werden kann.

Methoden

AsReadOnly<T>(T[])	Gibt einen schreibgeschützten Wrapper für das angegebene Array zurück.
BinarySearch(Array, Int32, Int32, Object)	Durchsucht einen Bereich von Elementen in einem eindimensionalen sortierten Array nach einem Wert, wobei die IComparable Schnittstelle verwendet wird, die von jedem Element des Arrays und vom angegebenen Wert implementiert wird.
BinarySearch(Array, Int32, Int32, Object, IComparer)	Durchsucht einen Bereich von Elementen in einem eindimensionalen sortierten Array nach einem Wert mithilfe der angegebenen IComparer Schnittstelle.
BinarySearch(Array, Object)	Durchsucht ein gesamtes eindimensionales sortiertes Array nach einem bestimmten Element, wobei die IComparable Schnittstelle verwendet wird, die von jedem Element des Arrays und vom angegebenen Objekt implementiert wird.
BinarySearch(Array, Object, IComparer)	Durchsucht ein gesamtes eindimensionales sortiertes Array nach einem Wert mithilfe der angegebenen IComparer Schnittstelle.
BinarySearch<T>(T[], Int32, Int32, T)	Durchsucht einen Bereich von Elementen in einem eindimensionalen sortierten Array nach einem Wert, wobei die IComparable<T> generische Schnittstelle verwendet wird, die von jedem Element der Array und vom angegebenen Wert implementiert wird.
BinarySearch<T>(T[], Int32, Int32, T, IComparer<T>)	Durchsucht einen Bereich von Elementen in einem eindimensionalen sortierten Array nach einem Wert mithilfe der angegebenen IComparer<T> generischen Schnittstelle.
BinarySearch<T>(T[], T)	Durchsucht ein gesamtes eindimensionales sortiertes Array nach einem bestimmten Element, wobei die IComparable<T> generische Schnittstelle verwendet wird, die von jedem Element der Array und vom angegebenen Objekt implementiert wird.
BinarySearch<T>(T[], T, IComparer<T>)	Durchsucht ein gesamtes eindimensionales sortiertes Array nach einem Wert mithilfe der angegebenen IComparer<T> generischen Schnittstelle.
Clear(Array)	Löscht den Inhalt eines Arrays.
Clear(Array, Int32, Int32)	Legt einen Bereich von Elementen in einem Array auf den Standardwert jedes Elementtyps fest.
Clone()	Erstellt eine flache Kopie der Array.
ConstrainedCopy(Array, Int32, Array, Int32, Int32)	Kopiert einen Bereich von Elementen aus einer Array beginnend am angegebenen Quellindex und fügt sie an eine andere Array ab dem angegebenen Zielindex ein. Garantiert, dass alle Änderungen rückgängig gemacht werden, wenn die Kopie nicht vollständig erfolgreich ist.
ConvertAll<TInput,TOutput>(TInput[], Converter<TInput,TOutput>)	Konvertiert ein Array eines Typs in ein Array eines anderen Typs.
Copy(Array, Array, Int32)	Kopiert einen Bereich von Elementen aus einem Array beginnend beim ersten Element und fügt sie in eine andere Array beginnend mit dem ersten Element ein. Die Länge wird als 32-Bit-Ganzzahl angegeben.
Copy(Array, Array, Int64)	Kopiert einen Bereich von Elementen aus einem Array beginnend beim ersten Element und fügt sie in eine andere Array beginnend mit dem ersten Element ein. Die Länge wird als 64-Bit-Ganzzahl angegeben.
Copy(Array, Int32, Array, Int32, Int32)	Kopiert einen Bereich von Elementen aus einer Array beginnend am angegebenen Quellindex und fügt sie an eine andere Array ab dem angegebenen Zielindex ein. Die Länge und die Indizes werden als ganze 32-Bit-Zahlen angegeben.
Copy(Array, Int64, Array, Int64, Int64)	Kopiert einen Bereich von Elementen aus einer Array beginnend am angegebenen Quellindex und fügt sie an eine andere Array ab dem angegebenen Zielindex ein. Die Länge und die Indizes werden als 64-Bit-Ganzzahlen angegeben.
CopyTo(Array, Int32)	Kopiert alle Elemente des aktuellen eindimensionalen Arrays in das angegebene eindimensionale Array ab dem angegebenen Zielarrayindex. Der Index wird als 32-Bit-Ganzzahl angegeben.
CopyTo(Array, Int64)	Kopiert alle Elemente des aktuellen eindimensionalen Arrays in das angegebene eindimensionale Array ab dem angegebenen Zielarrayindex. Der Index wird als 64-Bit-Ganzzahl angegeben.
CreateInstance(Type, Int32)	Erstellt eine eindimensionale Array der angegebenen Type und Länge mit nullbasierter Indizierung.
CreateInstance(Type, Int32, Int32)	Erstellt eine zweidimensionale Array der angegebenen Type und Bemaßungslängen mit nullbasierter Indizierung.
CreateInstance(Type, Int32, Int32, Int32)	Erstellt eine dreidimensionale Array der angegebenen Type und Bemaßungslängen mit nullbasierter Indizierung.
CreateInstance(Type, Int32[])	Erstellt eine multidimensionale Array der angegebenen Type und Bemaßungslängen mit nullbasierter Indizierung. Die Bemaßungslängen werden in einem Array mit 32-Bit-Ganzzahlen angegeben.
CreateInstance(Type, Int32[], Int32[])	Erstellt eine mehrdimensionale Array der angegebenen Type und Bemaßungslängen mit den angegebenen unteren Grenzen.
CreateInstance(Type, Int64[])	Erstellt eine multidimensionale Array der angegebenen Type und Bemaßungslängen mit nullbasierter Indizierung. Die Bemaßungslängen werden in einem Array mit 64-Bit-Ganzzahlen angegeben.
Empty<T>()	Gibt ein leeres Array zurück.
Equals(Object)	Bestimmt, ob das angegebene Objekt dem aktuellen Objekt entspricht. (Geerbt von Object)
Exists<T>(T[], Predicate<T>)	Bestimmt, ob das angegebene Array Elemente enthält, die den vom angegebenen Prädikat definierten Bedingungen entsprechen.
Fill<T>(T[], T)	Weist jedem Element der angegebenen arraydie angegebene valueT zu.
Fill<T>(T[], T, Int32, Int32)	Weist die angegebene value vom Typ T den Elementen der angegebenen array zu, die sich innerhalb des Bereichs startIndex (einschließlich) und der nächsten count Anzahl der Indizes befinden.
Find<T>(T[], Predicate<T>)	Sucht nach einem Element, das den vom angegebenen Prädikat definierten Bedingungen entspricht, und gibt das erste Vorkommen innerhalb der gesamten Arrayzurück.
FindAll<T>(T[], Predicate<T>)	Ruft alle Elemente ab, die den vom angegebenen Prädikat definierten Bedingungen entsprechen.
FindIndex<T>(T[], Int32, Int32, Predicate<T>)	Sucht nach einem Element, das den vom angegebenen Prädikat definierten Bedingungen entspricht, und gibt den nullbasierten Index des ersten Vorkommens innerhalb des Bereichs der Elemente in der Array zurück, die am angegebenen Index beginnt und die angegebene Anzahl von Elementen enthält.
FindIndex<T>(T[], Int32, Predicate<T>)	Sucht nach einem Element, das den vom angegebenen Prädikat definierten Bedingungen entspricht, und gibt den nullbasierten Index des ersten Vorkommens innerhalb des Elementbereichs in der Array zurück, der vom angegebenen Index bis zum letzten Element reicht.
FindIndex<T>(T[], Predicate<T>)	Sucht nach einem Element, das den vom angegebenen Prädikat definierten Bedingungen entspricht, und gibt den nullbasierten Index des ersten Vorkommens innerhalb der gesamten Arrayzurück.
FindLast<T>(T[], Predicate<T>)	Sucht nach einem Element, das den vom angegebenen Prädikat definierten Bedingungen entspricht, und gibt das letzte Vorkommen innerhalb der gesamten Arrayzurück.
FindLastIndex<T>(T[], Int32, Int32, Predicate<T>)	Sucht nach einem Element, das den vom angegebenen Prädikat definierten Bedingungen entspricht, und gibt den nullbasierten Index des letzten Vorkommens innerhalb des Bereichs der Elemente in der Array zurück, die die angegebene Anzahl von Elementen enthält und am angegebenen Index endet.
FindLastIndex<T>(T[], Int32, Predicate<T>)	Sucht nach einem Element, das den von dem angegebenen Prädikat definierten Bedingungen entspricht, und gibt den nullbasierten Index des letzten Vorkommens innerhalb des Bereichs der Elemente in der Array zurück, der sich vom ersten Element bis zum angegebenen Index erstreckt.
FindLastIndex<T>(T[], Predicate<T>)	Sucht nach einem Element, das den vom angegebenen Prädikat definierten Bedingungen entspricht, und gibt den nullbasierten Index des letzten Vorkommens innerhalb der gesamten Arrayzurück.
ForEach<T>(T[], Action<T>)	Führt die angegebene Aktion für jedes Element des angegebenen Arrays aus.
GetEnumerator()	Gibt einen IEnumerator für die Arrayzurück.
GetHashCode()	Dient als Standardhashfunktion. (Geerbt von Object)
GetLength(Int32)	Ruft eine 32-Bit-Ganzzahl, die die Anzahl der Elemente in der angegebenen Dimension der Arraydarstellt.
GetLongLength(Int32)	Ruft eine 64-Bit-Ganzzahl, die die Anzahl der Elemente in der angegebenen Dimension der Arraydarstellt.
GetLowerBound(Int32)	Ruft den Index des ersten Elements der angegebenen Dimension im Array ab.
GetType()	Ruft die Type der aktuellen Instanz ab. (Geerbt von Object)
GetUpperBound(Int32)	Ruft den Index des letzten Elements der angegebenen Dimension im Array ab.
GetValue(Int32)	Ruft den Wert an der angegebenen Position in der eindimensionalen Arrayab. Der Index wird als 32-Bit-Ganzzahl angegeben.
GetValue(Int32, Int32)	Ruft den Wert an der angegebenen Position in der zweidimensionalen Arrayab. Die Indizes werden als 32-Bit-Ganzzahlen angegeben.
GetValue(Int32, Int32, Int32)	Ruft den Wert an der angegebenen Position in der dreidimensionalen Arrayab. Die Indizes werden als 32-Bit-Ganzzahlen angegeben.
GetValue(Int32[])	Ruft den Wert an der angegebenen Position in der multidimensionalen Arrayab. Die Indizes werden als Array mit 32-Bit-Ganzzahlen angegeben.
GetValue(Int64)	Ruft den Wert an der angegebenen Position in der eindimensionalen Arrayab. Der Index wird als 64-Bit-Ganzzahl angegeben.
GetValue(Int64, Int64)	Ruft den Wert an der angegebenen Position in der zweidimensionalen Arrayab. Die Indizes werden als 64-Bit-Ganzzahlen angegeben.
GetValue(Int64, Int64, Int64)	Ruft den Wert an der angegebenen Position in der dreidimensionalen Arrayab. Die Indizes werden als 64-Bit-Ganzzahlen angegeben.
GetValue(Int64[])	Ruft den Wert an der angegebenen Position in der multidimensionalen Arrayab. Die Indizes werden als Array mit 64-Bit-Ganzzahlen angegeben.
IndexOf(Array, Object)	Sucht nach dem angegebenen Objekt und gibt den Index des ersten Vorkommens in einem eindimensionalen Array zurück.
IndexOf(Array, Object, Int32)	Sucht nach dem angegebenen Objekt in einem Bereich von Elementen eines eindimensionalen Arrays und gibt den Index des ersten Vorkommens zurück. Der Bereich erstreckt sich von einem angegebenen Index bis zum Ende des Arrays.
IndexOf(Array, Object, Int32, Int32)	Sucht nach dem angegebenen Objekt in einem Bereich von Elementen eines eindimensionalen Arrays und gibt den Index des ersten Vorkommens zurück. Der Bereich erstreckt sich von einem angegebenen Index für eine bestimmte Anzahl von Elementen.
IndexOf<T>(T[], T)	Sucht nach dem angegebenen Objekt und gibt den Index des ersten Vorkommens in einem eindimensionalen Array zurück.
IndexOf<T>(T[], T, Int32)	Sucht nach dem angegebenen Objekt in einem Bereich von Elementen eines eindimensionalen Arrays und gibt den Index des ersten Vorkommens zurück. Der Bereich erstreckt sich von einem angegebenen Index bis zum Ende des Arrays.
IndexOf<T>(T[], T, Int32, Int32)	Sucht nach dem angegebenen Objekt in einem Bereich von Elementen eines eindimensionalen Arrays und gibt den Index des ersten Vorkommens zurück. Der Bereich erstreckt sich von einem angegebenen Index für eine bestimmte Anzahl von Elementen.
Initialize()	Initialisiert jedes Element des Werttyps Array durch Aufrufen des parameterlosen Konstruktors des Werttyps.
LastIndexOf(Array, Object)	Sucht nach dem angegebenen Objekt und gibt den Index des letzten Vorkommens innerhalb der gesamten eindimensionalen Arrayzurück.
LastIndexOf(Array, Object, Int32)	Sucht nach dem angegebenen Objekt und gibt den Index des letzten Vorkommens innerhalb des Bereichs von Elementen in der eindimensionalen Array zurück, die sich vom ersten Element bis zum angegebenen Index erstreckt.
LastIndexOf(Array, Object, Int32, Int32)	Sucht nach dem angegebenen Objekt und gibt den Index des letzten Vorkommens innerhalb des Bereichs von Elementen in der eindimensionalen Array zurück, die die angegebene Anzahl von Elementen enthält und am angegebenen Index endet.
LastIndexOf<T>(T[], T)	Sucht nach dem angegebenen Objekt und gibt den Index des letzten Vorkommens innerhalb der gesamten Arrayzurück.
LastIndexOf<T>(T[], T, Int32)	Sucht nach dem angegebenen Objekt und gibt den Index des letzten Vorkommens innerhalb des Bereichs von Elementen in der Array zurück, die sich vom ersten Element bis zum angegebenen Index erstreckt.
LastIndexOf<T>(T[], T, Int32, Int32)	Sucht nach dem angegebenen Objekt und gibt den Index des letzten Vorkommens innerhalb des Elementbereichs in der Array zurück, der die angegebene Anzahl von Elementen enthält und am angegebenen Index endet.
MemberwiseClone()	Erstellt eine flache Kopie der aktuellen Object. (Geerbt von Object)
Resize<T>(T[], Int32)	Ändert die Anzahl der Elemente eines eindimensionalen Arrays in die angegebene neue Größe.
Reverse(Array)	Kehrt die Abfolge der Elemente in der gesamten eindimensionalen Arrayum.
Reverse(Array, Int32, Int32)	Kehrt die Abfolge einer Teilmenge der Elemente in der eindimensionalen Arrayum.
Reverse<T>(T[])	Umkehrt die Reihenfolge der Elemente im eindimensionalen generischen Array.
Reverse<T>(T[], Int32, Int32)	Umkehrt die Abfolge einer Teilmenge der Elemente im eindimensionalen generischen Array.
SetValue(Object, Int32)	Legt einen Wert auf das Element an der angegebenen Position in der eindimensionalen Arrayfest. Der Index wird als 32-Bit-Ganzzahl angegeben.
SetValue(Object, Int32, Int32)	Legt einen Wert auf das Element an der angegebenen Position in der zweidimensionalen Arrayfest. Die Indizes werden als 32-Bit-Ganzzahlen angegeben.
SetValue(Object, Int32, Int32, Int32)	Legt einen Wert auf das Element an der angegebenen Position in der dreidimensionalen Arrayfest. Die Indizes werden als 32-Bit-Ganzzahlen angegeben.
SetValue(Object, Int32[])	Legt einen Wert auf das Element an der angegebenen Position im mehrdimensionalen Arrayfest. Die Indizes werden als Array mit 32-Bit-Ganzzahlen angegeben.
SetValue(Object, Int64)	Legt einen Wert auf das Element an der angegebenen Position in der eindimensionalen Arrayfest. Der Index wird als 64-Bit-Ganzzahl angegeben.
SetValue(Object, Int64, Int64)	Legt einen Wert auf das Element an der angegebenen Position in der zweidimensionalen Arrayfest. Die Indizes werden als 64-Bit-Ganzzahlen angegeben.
SetValue(Object, Int64, Int64, Int64)	Legt einen Wert auf das Element an der angegebenen Position in der dreidimensionalen Arrayfest. Die Indizes werden als 64-Bit-Ganzzahlen angegeben.
SetValue(Object, Int64[])	Legt einen Wert auf das Element an der angegebenen Position im mehrdimensionalen Arrayfest. Die Indizes werden als Array mit 64-Bit-Ganzzahlen angegeben.
Sort(Array)	Sortiert die Elemente in einer ganzen eindimensionalen Array mithilfe der IComparable Implementierung jedes Elements der Array.
Sort(Array, Array)	Sortiert ein Paar eindimensionaler Array -Objekte (eins enthält die Schlüssel und der andere enthält die entsprechenden Elemente), basierend auf den Schlüsseln im ersten Array mithilfe der IComparable Implementierung jedes Schlüssels.
Sort(Array, Array, IComparer)	Sortiert ein Paar eindimensionaler Array -Objekte (eins enthält die Schlüssel und der andere enthält die entsprechenden Elemente) basierend auf den Schlüsseln in der ersten Array unter Verwendung der angegebenen IComparer.
Sort(Array, Array, Int32, Int32)	Sortiert einen Bereich von Elementen in einem Paar eindimensionaler Array -Objekten (eine enthält die Schlüssel und der andere enthält die entsprechenden Elemente), basierend auf den Schlüsseln im ersten Array mithilfe der IComparable Implementierung der einzelnen Schlüssel.
Sort(Array, Array, Int32, Int32, IComparer)	Sortiert einen Bereich von Elementen in einem Paar eindimensionaler Array -Objekten (eine enthält die Schlüssel und der andere enthält die entsprechenden Elemente) basierend auf den Schlüsseln in der ersten Array unter Verwendung der angegebenen IComparer.
Sort(Array, IComparer)	Sortiert die Elemente in einer eindimensionalen Array mithilfe der angegebenen IComparer.
Sort(Array, Int32, Int32)	Sortiert die Elemente in einem Bereich von Elementen in einem eindimensionalen Array mithilfe der IComparable Implementierung jedes Elements der Array.
Sort(Array, Int32, Int32, IComparer)	Sortiert die Elemente in einem Bereich von Elementen in einem eindimensionalen Array mithilfe der angegebenen IComparer.
Sort<T>(T[])	Sortiert die Elemente in einer ganzen Array mithilfe der IComparable<T> generischen Schnittstellenimplementierung jedes Elements der Array.
Sort<T>(T[], Comparison<T>)	Sortiert die Elemente in einer Array mithilfe der angegebenen Comparison<T>.
Sort<T>(T[], IComparer<T>)	Sortiert die Elemente in einer Array mithilfe der angegebenen IComparer<T> generischen Schnittstelle.
Sort<T>(T[], Int32, Int32)	Sortiert die Elemente in einem Elementbereich in einer Array mithilfe der IComparable<T> generischen Schnittstellenimplementierung jedes Elements der Array.
Sort<T>(T[], Int32, Int32, IComparer<T>)	Sortiert die Elemente in einem Elementbereich in einem Array mithilfe der angegebenen IComparer<T> generischen Schnittstelle.
Sort<TKey,TValue>(TKey[], TValue[])	Sortiert ein Paar von Array -Objekten (eines enthält die Schlüssel und der andere enthält die entsprechenden Elemente), basierend auf den Schlüsseln im ersten Array mithilfe der IComparable<T> generischen Schnittstellenimplementierung jedes Schlüssels.
Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>)	Sortiert ein Paar von Array -Objekten (eins enthält die Schlüssel und der andere enthält die entsprechenden Elemente), basierend auf den Schlüsseln in der ersten Array unter Verwendung der angegebenen IComparer<T> generischen Schnittstelle.
Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32)	Sortiert einen Elementbereich in einem Paar von Array -Objekten (eines enthält die Schlüssel und der andere enthält die entsprechenden Elemente), basierend auf den Schlüsseln in der ersten Array mithilfe der IComparable<T> generischen Schnittstellenimplementierung jedes Schlüssels.
Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>)	Sortiert einen Elementbereich in einem Paar von Array -Objekten (eines enthält die Schlüssel und der andere enthält die entsprechenden Elemente), basierend auf den Schlüsseln in der ersten Array mithilfe der angegebenen IComparer<T> generischen Schnittstelle.
ToString()	Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt. (Geerbt von Object)
TrueForAll<T>(T[], Predicate<T>)	Bestimmt, ob jedes Element im Array mit den bedingungen übereinstimmt, die durch das angegebene Prädikat definiert wurden.

Explizite Schnittstellenimplementierungen

ICollection.Count	Ruft die Anzahl der Elemente ab, die in der Arrayenthalten sind.
IList.Add(Object)	Das Aufrufen dieser Methode löst immer eine NotSupportedException Ausnahme aus.
IList.Clear()	Entfernt alle Elemente aus der IList.
IList.Contains(Object)	Bestimmt, ob sich ein Element im IListbefindet.
IList.IndexOf(Object)	Bestimmt den Index eines bestimmten Elements im IList.
IList.Insert(Int32, Object)	Fügt ein Element an die IList am angegebenen Index ein.
IList.Item[Int32]	Ruft das Element am angegebenen Index ab oder legt es fest.
IList.Remove(Object)	Entfernt das erste Vorkommen eines bestimmten Objekts aus dem IList.
IList.RemoveAt(Int32)	Entfernt das IList Element am angegebenen Index.
IStructuralComparable.CompareTo(Object, IComparer)	Bestimmt, ob das aktuelle Auflistungsobjekt vorangestellt ist, an derselben Position wie oder folgt einem anderen Objekt in der Sortierreihenfolge.
IStructuralEquatable.Equals(Object, IEqualityComparer)	Bestimmt, ob ein Objekt der aktuellen Instanz entspricht.
IStructuralEquatable.GetHashCode(IEqualityComparer)	Gibt einen Hashcode für die aktuelle Instanz zurück.

Erweiterungsmethoden

Cast<TResult>(IEnumerable)	Wandelt die Elemente eines IEnumerable in den angegebenen Typ um.
OfType<TResult>(IEnumerable)	Filtert die Elemente einer IEnumerable basierend auf einem angegebenen Typ.
AsParallel(IEnumerable)	Aktiviert die Parallelisierung einer Abfrage.
AsQueryable(IEnumerable)	Wandelt eine IEnumerable in eine IQueryableum.

Threadsicherheit

Öffentliche statische Elemente (Shared in Visual Basic) dieses Typs sind threadsicher. Instanzenmitglieder sind nicht garantiert threadsicher.

Diese Implementierung stellt keinen synchronisierten (threadsicheren) Wrapper für eine Arraybereit; .NET-Klassen, die auf Array basieren, stellen jedoch ihre eigene synchronisierte Version der Auflistung mithilfe der SyncRoot-Eigenschaft bereit.

Das Aufzählen durch eine Sammlung ist in erster Linie keine threadsichere Prozedur. Selbst wenn eine Auflistung synchronisiert wird, können andere Threads die Auflistung weiterhin ändern, wodurch der Enumerator eine Ausnahme auslöst. Um die Threadsicherheit während der Enumeration zu gewährleisten, können Sie die Auflistung entweder während der gesamten Enumeration sperren oder die Ausnahmen erfassen, die sich aus Änderungen ergeben, die von anderen Threads vorgenommen wurden.

Weitere Informationen

• Object
• Type
• Ausführen von Culture-Insensitive Zeichenfolgenvorgängen in Arrays
• Arrays (C#-Programmierhandbuch)
• Arrays in F#-
• Arrays in Visual Basic