Array Klasse

Definition

Stellt Methoden zum Erstellen, Bearbeiten, Durchsuchen und Sortieren von Arrays bereit und ist damit Basisklasse für alle Arrays in der Common Language Runtime.

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
Vererbung
Array
Attribute
Implementiert

Beispiele

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

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
*/
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 erstellt und initialisiert Array und dessen Eigenschaften und 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
 */
// 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. Sie wird jedoch weiterhin als Auflistung 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 -Klasse abgeleitet Array werden. Benutzer sollten die von der Sprache bereitgestellten Arraykonstrukte verwenden.

Ein Element ist ein Wert in einem Array . Die Länge eines Array ist die Gesamtzahl der Elemente, die es enthalten kann. Die untere Grenze des ein Array ist der Index des ersten Elements. Ein Array kann eine beliebige untere Grenze aufweisen, hat jedoch standardmäßig eine untere Grenze von 0 (null). Eine andere untere Grenze kann definiert werden, wenn eine Instanz der -Klasse mithilfe von erstellt Array CreateInstance wird. Ein mehrdimensionaler Array kann unterschiedliche Begrenzungen für jede Dimension aufweisen. Ein Array kann maximal 32 Dimensionen haben.

Im Gegensatz zu den Klassen in den System.Collections Namespaces Array verfügt ü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 objekt in das neue kopieren Array und das alte Array löschen.

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

nur .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 Konfigurationselements gcAllowVeryLargeObjects in der Laufzeitumgebung auf true festlegen.

Eindimensionale Arrays implementieren die System.Collections.Generic.IList<T> System.Collections.Generic.ICollection<T> generischen Schnittstellen , System.Collections.Generic.IEnumerable<T> , System.Collections.Generic.IReadOnlyList<T> und System.Collections.Generic.IReadOnlyCollection<T> . Die Implementierungen werden zur Laufzeit für Arrays bereitgestellt. Daher werden die generischen Schnittstellen nicht in der Deklarationssyntax für die Array -Klasse angezeigt. Darüber hinaus gibt es keine Referenzthemen für Schnittstellenmember, auf die nur durch Umwandeln eines Arrays in den generischen Schnittstellentyp (explizite Schnittstellenimplementierungen) zugegriffen werden kann. Beachten Sie bei der Umwandlung eines Arrays in eine dieser Schnittstellen, dass Member, die Elemente hinzufügen, einfügen oder entfernen, NotSupportedException auslösen.

Type -Objekte stellen Informationen zu Arraytypdeklarationen bereit. Array -Objekte mit demselben Arraytyp verwenden das gleiche 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 umgerechnet Array wird. Das heißt, typeof(System.Array).IsArray gibt zurück und gibt false typeof(System.Array).GetElementType null zurück.

Die Array.Copy -Methode kopiert Elemente nicht nur zwischen Arrays desselben Typs, sondern auch zwischen Standardarrays verschiedener Typen. Sie verarbeitet die Typcasting automatisch.

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

Es Array ist nicht garantiert, dass sortiert wird. Sie müssen vor Array dem Ausführen von Vorgängen (z. B. BinarySearch ) sortieren, die eine Sortierung des Array erfordern.

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

Eigenschaften

IsFixedSize

Ruft einen Wert ab, der angibt, ob das Array eine feste Größe aufweist.

IsReadOnly

Ruft einen Wert ab, der angibt, ob das Array schreibgeschützt ist.

IsSynchronized

Ruft einen Wert ab, der angibt, ob der Zugriff auf die Array synchronisiert (threadsicher) ist.

Length

Ruft die Gesamtanzahl der Elemente in allen Dimensionen im Array ab.

LongLength

Ruft eine 64-Bit-Ganzzahl ab, die die Gesamtanzahl der Elemente in allen Dimensionen des Array angibt.

MaxLength

Ruft die maximale Anzahl von Elementen ab, die in einem Array enthalten sein können.

Rank

Ruft den Rang (Anzahl der Dimensionen) von Array ab. Ein eindimensionales Array gibt z. B. 1 zurück, ein zweidimensionales Array gibt 2 zurück usw.

SyncRoot

Ruft ein Objekt ab, mit dem der Zugriff auf Array synchronisiert 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 sortierten eindimensionalen Array mithilfe der IComparable-Schnittstelle, die von jedem Element des Arrays und durch den angegebenen Wert implementiert wird, nach einem Wert.

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

Durchsucht einen Bereich von Elementen in einem sortierten eindimensionalen Array mithilfe der angegebenen IComparer-Schnittstelle nach einem Wert.

BinarySearch(Array, Object)

Durchsucht ein ganzes sortiertes eindimensionales Array mithilfe der IComparable-Schnittstelle, die von jedem Element des Arrays und durch das angegebene Objekt implementiert wird, nach einem bestimmten Element.

BinarySearch(Array, Object, IComparer)

Durchsucht ein ganzes sortiertes eindimensionales Array mithilfe der angegebenen IComparer-Schnittstelle nach einem Wert.

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

Durchsucht einen Bereich von Elementen in einem sortierten eindimensionalen Array mithilfe der generischen IComparable<T>-Schnittstelle, die von jedem Element des Array und vom angegebenen Wert implementiert wird, nach einem Wert.

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

Durchsucht einen Bereich von Elementen in einem sortierten eindimensionalen Array mithilfe der angegebenen generischen IComparer<T>-Schnittstelle nach einem Wert.

BinarySearch<T>(T[], T)

Durchsucht ein ganzes sortiertes eindimensionales Array mithilfe der generischen IComparable<T>-Schnittstelle, die von jedem Element des Array und vom angegebenen Objekt implementiert wird, nach einem bestimmten Element.

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

Durchsucht ein ganzes sortiertes eindimensionales Array mithilfe der angegebenen generischen IComparer<T>-Schnittstelle nach einem Wert.

Clear(Array)

Löscht den Inhalt eines Arrays.

Clear(Array, Int32, Int32)

Legt einen Bereich von Elementen in einem Array mit dem Standardwert der einzelnen Elementtypen fest.

Clone()

Erstellt eine flache Kopie von Array.

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

Kopiert einen beim angegebenen Quellindex beginnenden Elementbereich aus einem Array und fügt ihn ab dem angegebenen Zielindex in ein anderes Array ein. Stellt sicher, dass alle Änderungen rückgängig gemacht werden, wenn der Kopiervorgang nicht vollständig abgeschlossen wurde.

ConvertAll<TInput,TOutput>(TInput[], Converter<TInput,TOutput>)

Konvertiert ein Array des einen Typs in ein Array eines anderen Typs.

Copy(Array, Array, Int32)

Kopiert einen mit dem ersten Element beginnenden Elementbereich eines Array und fügt ihn ab dem ersten Element in ein anderes Array ein. Die Länge wird als 32-Bit-Ganzzahl angegeben.

Copy(Array, Array, Int64)

Kopiert einen mit dem ersten Element beginnenden Elementbereich eines Array und fügt ihn ab dem ersten Element in ein anderes Array ein. Die Länge wird als 64-Bit-Ganzzahl angegeben.

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

Kopiert einen beim angegebenen Quellindex beginnenden Elementbereich aus einem Array und fügt ihn ab dem angegebenen Zielindex in ein anderes Array ein. Die Länge und die Indizes werden als 32-Bit-Ganzzahlen angegeben.

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

Kopiert einen beim angegebenen Quellindex beginnenden Elementbereich aus einem Array und fügt ihn ab dem angegebenen Zielindex in ein anderes Array 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, beginnend am angegebenen Index des Zielarrays. Der Index wird als 32-Bit-Ganzzahl angegeben.

CopyTo(Array, Int64)

Kopiert alle Elemente des aktuellen eindimensionalen Arrays in das angegebene eindimensionale Array, beginnend am angegebenen Index des Zielarrays. Der Index wird als 64-Bit-Ganzzahl angegeben.

CreateInstance(Type, Int32)

Erstellt ein eindimensionales Array der angegebenen Länge und vom angegebenen Type mit nullbasierter Indizierung.

CreateInstance(Type, Int32, Int32)

Erstellt ein zweidimensionales Array vom angegebenen Type mit der für jede Dimension angegebenen Länge und mit nullbasierter Indizierung.

CreateInstance(Type, Int32, Int32, Int32)

Erstellt ein dreidimensionales Array vom angegebenen Type mit der für jede Dimension angegebenen Länge und mit nullbasierter Indizierung.

CreateInstance(Type, Int32[])

Erstellt ein mehrdimensionales Array vom angegebenen Type mit der für jede Dimension angegebenen Länge und mit nullbasierter Indizierung. Die Längen der Dimension werden in einem Array von 32-Bit-Ganzzahlen angegeben.

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

Erstellt ein mehrdimensionales Array vom angegebenen Type mit der für jede Dimension angegebenen Länge und Untergrenze.

CreateInstance(Type, Int64[])

Erstellt ein mehrdimensionales Array vom angegebenen Type mit der für jede Dimension angegebenen Länge und mit nullbasierter Indizierung. Die Längen der Dimension werden in einem Array von 64-Bit-Ganzzahlen angegeben.

Empty<T>()

Gibt ein leeres Array zurück.

Equals(Object)

Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist.

(Geerbt von Object)
Exists<T>(T[], Predicate<T>)

Bestimmt, ob das angegebene Array Elemente enthält, die mit den vom angegebenen Prädikat definierten Bedingungen übereinstimmen.

Fill<T>(T[], T)

Weist jedem Element des angegebenen array den angegebenen value vom Typ T zu.

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

Weist den angegebenen value des Typs T den Elementen des angegebenen array zu, die innerhalb des Bereichs von startIndex (inklusiv) und der nächsten count-Anzahl von Indizes liegen.

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

Sucht nach einem Element, das die durch das angegebene Prädikat definierten Bedingungen erfüllt, und gibt das erste Vorkommen im gesamten Array zurück.

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

Ruft alle Elemente ab, die die vom angegebenen Prädikat definierten Bedingungen erfüllen.

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

Sucht nach einem Element, das die durch das angegebene Prädikat definierten Bedingungen erfüllt, und gibt den nullbasierten Index des ersten Vorkommens innerhalb des Bereichs von Elementen im Array zurück, der am angegebenen Index beginnt und die angegebene Anzahl von Elementen umfasst.

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

Sucht nach einem Element, das die durch das angegebene Prädikat definierten Bedingungen erfüllt, und gibt den nullbasierten Index des ersten Vorkommens innerhalb des Bereichs von Elementen im Array zurück, der vom angegebenen Index bis zum letzten Element reicht.

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

Sucht nach einem Element, das die durch das angegebene Prädikat definierten Bedingungen erfüllt, und gibt den nullbasierten Index des ersten Vorkommens im gesamten Array zurück.

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

Sucht nach einem Element, das die durch das angegebene Prädikat definierten Bedingungen erfüllt, und gibt das letzte Vorkommen im gesamten Array zurück.

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

Sucht nach einem Element, das die durch das angegebene Prädikat definierten Bedingungen erfüllt, und gibt den nullbasierten Index des ersten Vorkommens innerhalb des Bereichs von Elementen im Array zurück, der die angegebene Anzahl von Elementen umfasst und am angegebenen Index endet.

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

Sucht nach einem Element, das die durch das angegebene Prädikat definierten Bedingungen erfüllt, und gibt den nullbasierten Index des letzten Vorkommens innerhalb des Bereichs von Elementen im Array zurück, der vom ersten Element bis zum angegeben Index reicht.

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

Sucht nach einem Element, das die durch das angegebene Prädikat definierten Bedingungen erfüllt, und gibt den nullbasierten Index des letzten Vorkommens im gesamten Array zurü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 das Arrayzurück.

GetHashCode()

Fungiert als Standardhashfunktion.

(Geerbt von Object)
GetLength(Int32)

Ruft eine 32-Bit-Ganzzahl ab, die die Anzahl der Elemente in der angegebenen Dimension des Array angibt.

GetLongLength(Int32)

Ruft eine 64-Bit-Ganzzahl ab, die die Anzahl der Elemente in der angegebenen Dimension des Array angibt.

GetLowerBound(Int32)

Ruft den Index des ersten Elements der angegebenen Dimension im Array ab.

GetType()

Ruft den 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 des eindimensionalen Array ab. Der Index wird als 32-Bit-Ganzzahl angegeben.

GetValue(Int32, Int32)

Ruft den Wert an der angegebenen Position des zweidimensionalen Array ab. Die Indizes werden als 32-Bit-Ganzzahlen angegeben.

GetValue(Int32, Int32, Int32)

Ruft den Wert an der angegebenen Position des dreidimensionalen Array ab. Die Indizes werden als 32-Bit-Ganzzahlen angegeben.

GetValue(Int32[])

Ruft den Wert an der angegebenen Position des mehrdimensionalen Array ab. Die Indizes werden als ein Array von 32-Bit-Ganzzahlen angegeben.

GetValue(Int64)

Ruft den Wert an der angegebenen Position des eindimensionalen Array ab. Der Index wird als 64-Bit-Ganzzahl angegeben.

GetValue(Int64, Int64)

Ruft den Wert an der angegebenen Position des zweidimensionalen Array ab. Die Indizes werden als 64-Bit-Ganzzahlen angegeben.

GetValue(Int64, Int64, Int64)

Ruft den Wert an der angegebenen Position des dreidimensionalen Array ab. Die Indizes werden als 64-Bit-Ganzzahlen angegeben.

GetValue(Int64[])

Ruft den Wert an der angegebenen Position des mehrdimensionalen Array ab. Die Indizes werden als ein Array von 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 das angegebene Objekt in einem Elementbereich eines eindimensionalen Arrays und gibt den Index seines ersten Auftretens zurück. Der Bereich erstreckt sich von einem angegebenen Index bis zum Ende des Arrays.

IndexOf(Array, Object, Int32, Int32)

Sucht das angegebene 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 angegebene 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 das angegebene 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 das angegebene Objekt in einem Elementbereich eines eindimensionalen Arrays und gibt den Index seines ersten Auftretens zurück. Der Bereich erstreckt sich von einem angegebenen Index für eine angegebene Anzahl von Elementen.

Initialize()

Initialisiert jedes Element des Werttyp-Array durch einen Aufruf des parameterlosen Konstruktors für den Werttyp.

LastIndexOf(Array, Object)

Sucht nach dem angegebenen Objekt und gibt den Index des letzten Vorkommens innerhalb des gesamten eindimensionalen Array zurück.

LastIndexOf(Array, Object, Int32)

Sucht nach dem angegebenen Objekt und gibt den Index des letzten Vorkommens innerhalb des Bereichs von Elementen im eindimensionalen Array zurück, das 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 im eindimensionalen Array zurück, das 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 des gesamten Array zurück.

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

Sucht nach dem angegebenen Objekt und gibt den Index des letzten Vorkommens innerhalb des Bereichs von Elementen in dem Array zurück, das 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 Bereichs von Elementen im Array zurück, das die angegebene Anzahl von Elementen enthält und am angegebenen Index endet.

MemberwiseClone()

Erstellt eine flache Kopie des 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 Reihenfolge der Elemente im gesamten eindimensionalen Array um.

Reverse(Array, Int32, Int32)

Kehrt die Reihenfolge einer Teilmenge der Elemente im eindimensionalen Array um.

Reverse<T>(T[])

Kehrt die Reihenfolge der Elemente im eindimensionalen generischen Array um.

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

Kehrt die Reihenfolge einer Teilmenge der Elemente im eindimensionalen generischen Array um.

SetValue(Object, Int32)

Legt das Element an der angegebenen Position des eindimensionalen Array auf einen Wert fest. Der Index wird als 32-Bit-Ganzzahl angegeben.

SetValue(Object, Int32, Int32)

Legt das Element an der angegebenen Position des zweidimensionalen Array auf einen Wert fest. Die Indizes werden als 32-Bit-Ganzzahlen angegeben.

SetValue(Object, Int32, Int32, Int32)

Legt einen Wert auf das Element an der angegebenen Position im dreidimensionalen Array fest. Die Indizes werden als 32-Bit-Ganzzahlen angegeben.

SetValue(Object, Int32[])

Legt das Element an der angegebenen Position des mehrdimensionalen Array auf einen Wert fest. Die Indizes werden als ein Array von 32-Bit-Ganzzahlen angegeben.

SetValue(Object, Int64)

Legt das Element an der angegebenen Position des eindimensionalen Array auf einen Wert fest. Der Index wird als 64-Bit-Ganzzahl angegeben.

SetValue(Object, Int64, Int64)

Legt das Element an der angegebenen Position des zweidimensionalen Array auf einen Wert fest. Die Indizes werden als 64-Bit-Ganzzahlen angegeben.

SetValue(Object, Int64, Int64, Int64)

Legt einen Wert auf das Element an der angegebenen Position im dreidimensionalen Array fest. Die Indizes werden als 64-Bit-Ganzzahlen angegeben.

SetValue(Object, Int64[])

Legt das Element an der angegebenen Position des mehrdimensionalen Array auf einen Wert fest. Die Indizes werden als ein Array von 64-Bit-Ganzzahlen angegeben.

Sort(Array)

Sortiert die Elemente in einem ganzen eindimensionalen Array mithilfe der IComparable-Implementierung jedes Elements des Array.

Sort(Array, Array)

Sortiert ein Paar eindimensionaler Array-Objekte (das eine enthält die Schlüssel und das andere die entsprechenden Werte) nach den Schlüsseln im ersten Array und verwendet dabei die IComparable-Implementierung der einzelnen Schlüssel.

Sort(Array, Array, IComparer)

Sortiert ein Paar von eindimensionalen Array-Objekten (ein Objekt enthält die Schlüssel und das andere die entsprechenden Elemente) nach den Schlüsseln im ersten Array und verwendet dabei den angegebenen IComparer.

Sort(Array, Array, Int32, Int32)

Sortiert einen Bereich von Elementen in einem Paar von eindimensionalen Array-Objekten (das eine enthält die Schlüssel und das andere die entsprechenden Werte) nach den Schlüsseln im ersten Array und verwendet dabei die IComparable-Implementierung jedes Schlüssels.

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

Sortiert einen Bereich von Elementen in einem Paar von eindimensionalen Array-Objekten (das eine enthält die Schlüssel und das andere die entsprechenden Werte) nach den Schlüsseln im ersten Array und verwendet dabei den angegebenen IComparer.

Sort(Array, IComparer)

Sortiert die Elemente in einem eindimensionalen Array mithilfe des angegebenen IComparer.

Sort(Array, Int32, Int32)

Sortiert die Elemente in einem Bereich von Elementen in einem eindimensionalen Array mithilfe der IComparable-Implementierung jedes Elements des Array.

Sort(Array, Int32, Int32, IComparer)

Sortiert die Elemente in einem Bereich von Elementen in einem eindimensionalen Array mithilfe des angegebenen IComparer.

Sort<T>(T[])

Sortiert die Elemente in einem ganzen Array mithilfe der Implementierung der generischen IComparable<T>-Schnittstelle jedes Elements des Array.

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

Sortiert die Elemente in einem Array mithilfe des angegebenen Comparison<T>.

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

Sortiert die Elemente in einem Array mithilfe der angegebenen generischen IComparer<T>-Schnittstelle.

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

Sortiert die Elemente in einem Bereich von Elementen in einem Array mithilfe der Implementierung der generischen IComparable<T>-Schnittstelle jedes Elements des Array.

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

Sortiert die Elemente in einem Bereich von Elementen im Array mithilfe der angegebenen generischen IComparer<T>-Schnittstelle.

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

Sortiert ein Paar von Array-Objekten (das eine enthält die Schlüssel und das andere die entsprechenden Werte) nach den Schlüsseln im ersten Array und verwendet dabei die Implementierung der generischen IComparable<T>-Schnittstelle jedes Schlüssels.

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

Sortiert ein Paar von Array-Objekten (das eine enthält die Schlüssel und das andere die entsprechenden Werte) nach den Schlüsseln im ersten Array und verwendet dabei die angegebene generische IComparer<T>-Schnittstelle.

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

Sortiert einen Bereich von Elementen in einem Paar von Array-Objekten (das eine enthält die Schlüssel und das andere die entsprechenden Werte) nach den Schlüsseln im ersten Array und verwendet dabei die Implementierung der generischen IComparable<T>-Schnittstelle jedes Schlüssels.

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

Sortiert einen Bereich von Elementen in einem Paar von Array-Objekten (das eine enthält die Schlüssel und das andere die entsprechenden Werte) nach den Schlüsseln im ersten Array und verwendet dabei die angegebene generische IComparer<T>-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 die vom angegebenen Prädikat definierten Bedingungen erfüllt.

Explizite Schnittstellenimplementierungen

ICollection.Count

Ruft die Anzahl der Elemente ab, die in Array enthalten sind.

ICollection.IsSynchronized

Ruft einen Wert ab, der angibt, ob der Zugriff auf Array synchronisiert (threadsicher) ist.

ICollection.SyncRoot

Ruft ein Objekt ab, mit dem der Zugriff auf Array synchronisiert werden kann.

IList.Add(Object)

Beim Aufrufen dieser Methode wird immer eine NotSupportedException-Ausnahme ausgelöst.

IList.Clear()

Entfernt alle Elemente aus IList.

IList.Contains(Object)

Bestimmt, ob sich ein Element in IList befindet.

IList.IndexOf(Object)

Bestimmt den Index eines bestimmten Elements in der IList.

IList.Insert(Int32, Object)

Fügt am angegebenen Index ein Element in die IList ein.

IList.IsFixedSize

Ruft einen Wert ab, der angibt, ob die Array eine feste Größe hat.

IList.IsReadOnly

Ruft einen Wert ab, der angibt, ob die Array schreibgeschützt ist.

IList.Item[Int32]

Ruft das Element am angegebenen Index ab oder legt dieses fest.

IList.Remove(Object)

Entfernt das erste Vorkommen eines angegebenen Objekts aus der IList.

IList.RemoveAt(Int32)

Entfernt das IList-Element am angegebenen Index.

IStructuralComparable.CompareTo(Object, IComparer)

Bestimmt, ob das aktuelle Auflistungsobjekt in der Sortierreihenfolge vor oder nach einem anderen Objekt oder an derselben Position auftritt.

IStructuralEquatable.Equals(Object, IEqualityComparer)

Bestimmt, ob ein Objekt gleich der aktuellen Instanz ist.

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 eines IEnumerable anhand eines angegebenen Typs

AsParallel(IEnumerable)

Ermöglicht die Parallelisierung einer Abfrage.

AsQueryable(IEnumerable)

Konvertiert einen IEnumerable in einen IQueryable.

Gilt für

Threadsicherheit

Öffentliche statische Shared Member (in Visual Basic) dieses Typs sind threadsicher. Bei Instanzmembern ist die Threadsicherheit nicht gewährleistet.

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

Die Enumeration einer Auflistung ist systemintern keine threadsichere Prozedur. Selbst wenn eine Auflistung synchronisiert wird, besteht die Möglichkeit, dass andere Threads sie ändern. Dies führt dazu, dass der Enumerator eine Ausnahme auslöst. Um während der Enumeration Threadsicherheit zu gewährleisten, können Sie entweder die Auflistung während der gesamten Enumeration sperren oder die Ausnahmen, die aus von anderen Threads stammenden Änderungen resultieren, abfangen.

Siehe auch