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.Provides methods for creating, manipulating, searching, and sorting arrays, thereby serving as the base class for all arrays in the common language runtime.

public ref class Array abstract : ICloneable, System::Collections::IList, System::Collections::IStructuralComparable, System::Collections::IStructuralEquatable
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public abstract class Array : ICloneable, System.Collections.IList, System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable
type Array = class
    interface ICloneable
    interface ICollection
    interface IList
    interface IEnumerable
    interface IStructuralComparable
    interface IStructuralEquatable
Public MustInherit Class Array
Implements ICloneable, IList, IStructuralComparable, IStructuralEquatable
Vererbung
Array
Attribute
Implementiert

Beispiele

Hinweis

Einige der C#-Beispiele in diesem Artikel werden in der Inlinecodeausführung und dem Playground von Try.NET ausgeführt.Some of the C# examples in this article run in the Try.NET inline code runner and playground. Wenn vorhanden, klicken Sie auf die Schaltfläche Ausführen, um ein Beispiel in einem interaktiven Fenster auszuführen.When present, select the Run button to run an example in an interactive window. Nachdem Sie den Code ausgeführt haben, können Sie ihn ändern und den geänderten Code durch erneutes Anklicken der Schaltfläche Ausführen ausführen.Once you execute the code, you can modify it and run the modified code by selecting Run again. Der geänderte Code wird entweder im interaktiven Fenster ausgeführt, oder das interaktive Fenster zeigt alle C#-Compilerfehlermeldungen an, wenn die Kompilierung fehlschlägt.The modified code either runs in the interactive window or, if compilation fails, the interactive window displays all C# compiler error messages.

Im folgenden Codebeispiel wird gezeigt, wie Array.Copy Elemente zwischen einem Array vom Typ Integer und einem Array vom Typ Objectkopiert.The following code example shows how Array.Copy copies elements between an array of type integer and an array of type Object.

using namespace System;

void PrintValues(array<Object^>^myArr);
void PrintValues(array<int>^myArr);
void main()
{
    // Creates and initializes a new int array and a new Object array.
    array<int>^myIntArray = { 1,2,3,4,5 };
    array<Object^>^myObjArray = { 26,27,28,29,30 };

    // Prints the initial values of both arrays.
    Console::WriteLine("Initially:");
    Console::Write("int array:   ");
    PrintValues(myIntArray);
    Console::Write("Object array:");
    PrintValues(myObjArray);

    // Copies the first two elements from the int array to the Object array.
    System::Array::Copy(myIntArray, myObjArray, 2);

    // Prints the values of the modified arrays.
    Console::WriteLine("\nAfter copying the first two elements of the int array to the Object array:");
    Console::Write("int array:   ");
    PrintValues(myIntArray);
    Console::Write("Object array:");
    PrintValues(myObjArray);

    // Copies the last two elements from the Object array to the int array.
    System::Array::Copy(myObjArray, myObjArray->GetUpperBound(0) - 1, myIntArray, myIntArray->GetUpperBound(0) - 1, 2);

    // Prints the values of the modified arrays.
    Console::WriteLine("\nAfter copying the last two elements of the Object array to the int array:");
    Console::Write("int array:   ");
    PrintValues(myIntArray);
    Console::Write("Object array:");
    PrintValues(myObjArray);
}

void PrintValues(array<Object^>^myArr)
{
    for (int i = 0; i < myArr->Length; i++)
    {
        Console::Write("\t{0}", myArr[i]);

    }
    Console::WriteLine();
}

void PrintValues(array<int>^myArr)
{
    for (int i = 0; i < myArr->Length; i++)
    {
        Console::Write("\t{0}", myArr[i]);

    }
    Console::WriteLine();
}


/*
This code produces the following output.

Initially:
int array:       1    2    3    4    5
Object array:    26    27    28    29    30
After copying the first two elements of the int array to the Object array:
int array:       1    2    3    4    5
Object array:    1    2    28    29    30
After copying the last two elements of the Object array to the int array:
int array:       1    2    3    29    30
Object array:    1    2    28    29    30
*/
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 eine Array erstellt und initialisiert, und die zugehörigen Eigenschaften und deren Elemente werden angezeigt.The following code example creates and initializes an Array and displays its properties and its elements.

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 Int32.
Array myArr = Array.CreateInstance(typeof(Int32), 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.The Array class is not part of the System.Collections namespaces. Sie wird jedoch immer noch als Sammlung betrachtet, da Sie auf der IList-Schnittstelle basiert.However, it is still considered a collection because it is based on the IList interface.

Die Array-Klasse ist die Basisklasse für sprach Implementierungen, die Arrays unterstützen.The Array class is the base class for language implementations that support arrays. Allerdings können nur das System und die Compiler explizit von der Array Klasse abgeleitet werden.However, only the system and compilers can derive explicitly from the Array class. Benutzer sollten die von der Sprache bereitgestellten Arraykonstrukte verwenden.Users should employ the array constructs provided by the language.

Ein Element ist ein Wert in einem Array.An element is a value in an Array. Die Länge einer Array ist die Gesamtzahl der Elemente, die Sie enthalten kann.The length of an Array is the total number of elements it can contain. Die untere Grenze des ein Array ist der Index des ersten Elements.The lower bound of an Array is the index of its first element. Ein-Array kann über eine beliebige untere Grenze verfügen, hat jedoch standardmäßig eine untere Grenze von NULL.An Array can have any lower bound, but it has a lower bound of zero by default. Eine andere Untergrenze kann definiert werden, wenn eine Instanz der Array-Klasse mit CreateInstanceerstellt wird. Ein mehrdimensionaler Array kann für jede Dimension über unterschiedliche Begrenzungen verfügen.A different lower bound can be defined when creating an instance of the Array class using CreateInstance.A multidimensional Array can have different bounds for each dimension. Ein Array kann maximal 32 Dimensionen aufweisen.An array can have a maximum of 32 dimensions.

Im Gegensatz zu den Klassen in den System.Collections-Namespaces verfügt Array über eine festgelegte Kapazität.Unlike the classes in the System.Collections namespaces, Array has a fixed capacity. 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.To increase the capacity, you must create a new Array object with the required capacity, copy the elements from the old Array object to the new one, and delete the old Array.

Die Array Größe ist auf insgesamt 4 Milliarden Elemente und auf einen maximalen Index von 0x7fefffff in einer beliebigen Dimension (0x7fffffc7 für Byte Arrays und Arrays von Einzel Byte Strukturen) beschränkt.The array size is limited to a total of 4 billion elements, and to a maximum index of 0X7FEFFFFF in any given dimension (0X7FFFFFC7 for byte arrays and arrays of single-byte structures).

Nur .NET Framework: Standardmäßig beträgt die maximale Größe eines Array 2 Gigabyte (GB)..NET Framework only: By default, the maximum size of an Array is 2 gigabytes (GB). In einer 64-Bit-Umgebung können Sie die Größenbeschränkung vermeiden, indem Sie das enabled-Attribut des gcallowverylargeobjects -Konfigurations Elements auf true in der Laufzeitumgebung festlegen.In a 64-bit environment, you can avoid the size restriction by setting the enabled attribute of the gcAllowVeryLargeObjects configuration element to true in the run-time environment.

Eindimensionale Arrays implementieren die generischen Schnittstellen 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>.Single-dimensional arrays implement the System.Collections.Generic.IList<T>, System.Collections.Generic.ICollection<T>, System.Collections.Generic.IEnumerable<T>, System.Collections.Generic.IReadOnlyList<T> and System.Collections.Generic.IReadOnlyCollection<T> generic interfaces. Die Implementierungen werden zur Laufzeit für Arrays bereitgestellt, und infolgedessen werden die generischen Schnittstellen nicht in der Deklarations Syntax für die Array-Klasse angezeigt.The implementations are provided to arrays at run time, and as a result, the generic interfaces do not appear in the declaration syntax for the Array class. Außerdem sind keine Referenz Themen für Schnittstellenmember verfügbar, auf die nur durch Umwandeln eines Arrays in den generischen Schnittstellentyp (explizite Schnittstellen Implementierungen) zugegriffen werden kann.In addition, there are no reference topics for interface members that are accessible only by casting an array to the generic interface type (explicit interface implementations). Beim Umwandeln eines Arrays in eine dieser Schnittstellen ist es wichtig zu beachten, dass Member, die Elemente hinzufügen, einfügen oder entfernen, NotSupportedExceptionauslösen.The key thing to be aware of when you cast an array to one of these interfaces is that members which add, insert, or remove elements throw NotSupportedException.

Type-Objekte stellen Informationen über Arraytypdeklarationen bereit.Type objects provide information about array type declarations. Array Objekte mit demselben Arraytyp verwenden dasselbe Type Objekt.Array objects with the same array type share the same Type object.

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 Arrayumgewandelt wird.Type.IsArray and Type.GetElementType might not return the expected results with Array because if an array is cast to the type Array, the result is an object, not an array. Das heißt, typeof(System.Array).IsArray gibt falsezurück, und typeof(System.Array).GetElementType gibt nullzurück.That is, typeof(System.Array).IsArray returns false, and typeof(System.Array).GetElementType returns null.

Die Array.Copy-Methode kopiert Elemente nicht nur zwischen Arrays desselben Typs, sondern auch zwischen Standard Arrays unterschiedlicher Typen. die Typumwandlung wird automatisch verarbeitet.The Array.Copy method copies elements not only between arrays of the same type but also between standard arrays of different types; it handles type casting automatically.

Einige Methoden, z. b. CreateInstance, Copy, CopyTo, GetValueund SetValue, stellen über Ladungen bereit, die ganzzahlige 64-Bit-Werte als Parameter für große Kapazitäts Arrays akzeptieren.Some methods, such as CreateInstance, Copy, CopyTo, GetValue, and SetValue, provide overloads that accept 64-bit integers as parameters to accommodate large capacity arrays. LongLength und GetLongLength geben 64-Bit-Ganzzahlen zurück, die die Länge des Arrays angeben.LongLength and GetLongLength return 64-bit integers indicating the length of the array.

Es ist nicht garantiert, dass die Array sortiert wird.The Array is not guaranteed to be sorted. Sie müssen die Array vor dem Durchführen von Vorgängen (z. b. BinarySearch) Sortieren, bei denen die Array sortiert werden muss.You must sort the Array prior to performing operations (such as BinarySearch) that require the Array to be sorted.

Die Verwendung eines Array Objekts von Zeigern in nativem Code wird nicht unterstützt und löst eine NotSupportedException für mehrere Methoden aus.Using an Array object of pointers in native code is not supported and will throw a NotSupportedException for several methods.

Eigenschaften

IsFixedSize

Ruft einen Wert ab, der angibt, ob das Array eine feste Größe aufweist.Gets a value indicating whether the Array has a fixed size.

IsReadOnly

Ruft einen Wert ab, der angibt, ob das Array schreibgeschützt ist.Gets a value indicating whether the Array is read-only.

IsSynchronized

Ruft einen Wert ab, der angibt, ob der Zugriff auf die Array synchronisiert (threadsicher) ist.Gets a value indicating whether access to the Array is synchronized (thread safe).

Length

Ruft die Gesamtanzahl der Elemente in allen Dimensionen im Array ab.Gets the total number of elements in all the dimensions of the Array.

LongLength

Ruft eine 64-Bit-Ganzzahl ab, die die Gesamtanzahl der Elemente in allen Dimensionen des Array angibt.Gets a 64-bit integer that represents the total number of elements in all the dimensions of the Array.

Rank

Ruft der Rang (Anzahl der Dimensionen) des Array ab.Gets the rank (number of dimensions) of the Array. Beispielsweise gibt ein eindimensionales Array 1 zurück, eines zweidimensionalen Arrays gibt 2 zurück, usw.For example, a one-dimensional array returns 1, a two-dimensional array returns 2, and so on.

SyncRoot

Ruft ein Objekt ab, mit dem der Zugriff auf Array synchronisiert werden kann.Gets an object that can be used to synchronize access to the Array.

Methoden

AsReadOnly<T>(T[])

Gibt einen schreibgeschützten Wrapper für das angegebene Array zurück.Returns a read-only wrapper for the specified array.

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.Searches a range of elements in a one-dimensional sorted array for a value, using the IComparable interface implemented by each element of the array and by the specified value.

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

Durchsucht einen Bereich von Elementen in einem sortierten eindimensionalen Array mithilfe der angegebenen IComparer-Schnittstelle nach einem Wert.Searches a range of elements in a one-dimensional sorted array for a value, using the specified IComparer interface.

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.Searches an entire one-dimensional sorted array for a specific element, using the IComparable interface implemented by each element of the array and by the specified object.

BinarySearch(Array, Object, IComparer)

Durchsucht ein ganzes sortiertes eindimensionales Array mithilfe der angegebenen IComparer-Schnittstelle nach einem Wert.Searches an entire one-dimensional sorted array for a value using the specified IComparer interface.

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.Searches a range of elements in a one-dimensional sorted array for a value, using the IComparable<T> generic interface implemented by each element of the Array and by the specified value.

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.Searches a range of elements in a one-dimensional sorted array for a value, using the specified IComparer<T> generic interface.

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.Searches an entire one-dimensional sorted array for a specific element, using the IComparable<T> generic interface implemented by each element of the Array and by the specified object.

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

Durchsucht ein ganzes sortiertes eindimensionales Array mithilfe der angegebenen generischen IComparer<T>-Schnittstelle nach einem Wert.Searches an entire one-dimensional sorted array for a value using the specified IComparer<T> generic interface.

Clear(Array, Int32, Int32)

Legt einen Bereich von Elementen in einem Array mit dem Standardwert der einzelnen Elementtypen fest.Sets a range of elements in an array to the default value of each element type.

Clone()

Erstellt eine flache Kopie von Array.Creates a shallow copy of the 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.Copies a range of elements from an Array starting at the specified source index and pastes them to another Array starting at the specified destination index. Stellt sicher, dass alle Änderungen rückgängig gemacht werden, wenn der Kopiervorgang nicht vollständig abgeschlossen wurde.Guarantees that all changes are undone if the copy does not succeed completely.

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

Konvertiert ein Array des einen Typs in ein Array eines anderen Typs.Converts an array of one type to an array of another type.

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.Copies a range of elements from an Array starting at the first element and pastes them into another Array starting at the first element. Die Länge wird als 32-Bit-Ganzzahl angegeben.The length is specified as a 32-bit integer.

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.Copies a range of elements from an Array starting at the first element and pastes them into another Array starting at the first element. Die Länge wird als 64-Bit-Ganzzahl angegeben.The length is specified as a 64-bit integer.

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.Copies a range of elements from an Array starting at the specified source index and pastes them to another Array starting at the specified destination index. Die Länge und die Indizes werden als 32-Bit-Ganzzahlen angegeben.The length and the indexes are specified as 32-bit integers.

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.Copies a range of elements from an Array starting at the specified source index and pastes them to another Array starting at the specified destination index. Die Länge und die Indizes werden als 64-Bit-Ganzzahlen angegeben.The length and the indexes are specified as 64-bit integers.

CopyTo(Array, Int32)

Kopiert alle Elemente des aktuellen eindimensionalen Arrays in das angegebene eindimensionale Array, beginnend am angegebenen Index des Zielarrays.Copies all the elements of the current one-dimensional array to the specified one-dimensional array starting at the specified destination array index. Der Index wird als 32-Bit-Ganzzahl angegeben.The index is specified as a 32-bit integer.

CopyTo(Array, Int64)

Kopiert alle Elemente des aktuellen eindimensionalen Arrays in das angegebene eindimensionale Array, beginnend am angegebenen Index des Zielarrays.Copies all the elements of the current one-dimensional array to the specified one-dimensional array starting at the specified destination array index. Der Index wird als 64-Bit-Ganzzahl angegeben.The index is specified as a 64-bit integer.

CreateInstance(Type, Int32)

Erstellt ein eindimensionales Array der angegebenen Länge und vom angegebenen Type mit nullbasierter Indizierung.Creates a one-dimensional Array of the specified Type and length, with zero-based indexing.

CreateInstance(Type, Int32, Int32)

Erstellt ein zweidimensionales Array vom angegebenen Type mit der für jede Dimension angegebenen Länge und mit nullbasierter Indizierung.Creates a two-dimensional Array of the specified Type and dimension lengths, with zero-based indexing.

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.Creates a three-dimensional Array of the specified Type and dimension lengths, with zero-based indexing.

CreateInstance(Type, Int32[])

Erstellt ein mehrdimensionales Array vom angegebenen Type mit der für jede Dimension angegebenen Länge und mit nullbasierter Indizierung.Creates a multidimensional Array of the specified Type and dimension lengths, with zero-based indexing. Die Längen der Dimension werden in einem Array von 32-Bit-Ganzzahlen angegeben.The dimension lengths are specified in an array of 32-bit integers.

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

Erstellt ein mehrdimensionales Array vom angegebenen Type mit der für jede Dimension angegebenen Länge und Untergrenze.Creates a multidimensional Array of the specified Type and dimension lengths, with the specified lower bounds.

CreateInstance(Type, Int64[])

Erstellt ein mehrdimensionales Array vom angegebenen Type mit der für jede Dimension angegebenen Länge und mit nullbasierter Indizierung.Creates a multidimensional Array of the specified Type and dimension lengths, with zero-based indexing. Die Längen der Dimension werden in einem Array von 64-Bit-Ganzzahlen angegeben.The dimension lengths are specified in an array of 64-bit integers.

Empty<T>()

Gibt ein leeres Array zurück.Returns an empty array.

Equals(Object)

Ermittelt, ob das angegebene Objekt und das aktuelle Objekt gleich sind.Determines whether the specified object is equal to the current object.

(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.Determines whether the specified array contains elements that match the conditions defined by the specified predicate.

Fill<T>(T[], T)

Weist jedem Element des angegebenen array den angegebenen value vom Typ T zu.Assigns the given value of type T to each element of the specified array.

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.Assigns the given value of type T to the elements of the specified array which are within the range of startIndex (inclusive) and the next count number of indices.

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.Searches for an element that matches the conditions defined by the specified predicate, and returns the first occurrence within the entire Array.

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

Ruft alle Elemente ab, die die vom angegebenen Prädikat definierten Bedingungen erfüllen.Retrieves all the elements that match the conditions defined by the specified predicate.

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.Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the first occurrence within the range of elements in the Array that starts at the specified index and contains the specified number of elements.

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.Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the first occurrence within the range of elements in the Array that extends from the specified index to the last element.

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.Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the first occurrence within the entire Array.

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.Searches for an element that matches the conditions defined by the specified predicate, and returns the last occurrence within the entire Array.

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.Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the last occurrence within the range of elements in the Array that contains the specified number of elements and ends at the specified index.

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.Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the last occurrence within the range of elements in the Array that extends from the first element to the specified index.

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.Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the last occurrence within the entire Array.

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

Führt die angegebene Aktion für jedes Element des angegebenen Arrays aus.Performs the specified action on each element of the specified array.

GetEnumerator()

Gibt einen IEnumerator für das Arrayzurück.Returns an IEnumerator for the Array.

GetHashCode()

Dient als die Standard-HashfunktionServes as the default hash function.

(Geerbt von Object)
GetLength(Int32)

Ruft eine 32-Bit-Ganzzahl ab, die die Anzahl der Elemente in der angegebenen Dimension des Array angibt.Gets a 32-bit integer that represents the number of elements in the specified dimension of the Array.

GetLongLength(Int32)

Ruft eine 64-Bit-Ganzzahl ab, die die Anzahl der Elemente in der angegebenen Dimension des Array angibt.Gets a 64-bit integer that represents the number of elements in the specified dimension of the Array.

GetLowerBound(Int32)

Ruft den Index des ersten Elements der angegebenen Dimension im Array ab.Gets the index of the first element of the specified dimension in the array.

GetType()

Ruft den Type der aktuellen Instanz ab.Gets the Type of the current instance.

(Geerbt von Object)
GetUpperBound(Int32)

Ruft den Index des letzten Elements der angegebenen Dimension im Array ab.Gets the index of the last element of the specified dimension in the array.

GetValue(Int32)

Ruft den Wert an der angegebenen Position des eindimensionalen Array ab.Gets the value at the specified position in the one-dimensional Array. Der Index wird als 32-Bit-Ganzzahl angegeben.The index is specified as a 32-bit integer.

GetValue(Int32, Int32)

Ruft den Wert an der angegebenen Position des zweidimensionalen Array ab.Gets the value at the specified position in the two-dimensional Array. Die Indizes werden als 32-Bit-Ganzzahlen angegeben.The indexes are specified as 32-bit integers.

GetValue(Int32, Int32, Int32)

Ruft den Wert an der angegebenen Position des dreidimensionalen Array ab.Gets the value at the specified position in the three-dimensional Array. Die Indizes werden als 32-Bit-Ganzzahlen angegeben.The indexes are specified as 32-bit integers.

GetValue(Int32[])

Ruft den Wert an der angegebenen Position des mehrdimensionalen Array ab.Gets the value at the specified position in the multidimensional Array. Die Indizes werden als ein Array von 32-Bit-Ganzzahlen angegeben.The indexes are specified as an array of 32-bit integers.

GetValue(Int64)

Ruft den Wert an der angegebenen Position des eindimensionalen Array ab.Gets the value at the specified position in the one-dimensional Array. Der Index wird als 64-Bit-Ganzzahl angegeben.The index is specified as a 64-bit integer.

GetValue(Int64, Int64)

Ruft den Wert an der angegebenen Position des zweidimensionalen Array ab.Gets the value at the specified position in the two-dimensional Array. Die Indizes werden als 64-Bit-Ganzzahlen angegeben.The indexes are specified as 64-bit integers.

GetValue(Int64, Int64, Int64)

Ruft den Wert an der angegebenen Position des dreidimensionalen Array ab.Gets the value at the specified position in the three-dimensional Array. Die Indizes werden als 64-Bit-Ganzzahlen angegeben.The indexes are specified as 64-bit integers.

GetValue(Int64[])

Ruft den Wert an der angegebenen Position des mehrdimensionalen Array ab.Gets the value at the specified position in the multidimensional Array. Die Indizes werden als Array von 64-Bit-Ganzzahlen angegeben.The indexes are specified as an array of 64-bit integers.

IndexOf(Array, Object)

Sucht nach dem angegebenen Objekt und gibt den Index des ersten Vorkommens in einem eindimensionalen Array zurück.Searches for the specified object and returns the index of its first occurrence in a one-dimensional array.

IndexOf(Array, Object, Int32)

Sucht das angegebene Objekt in einem Elementbereich eines eindimensionalen Arrays und gibt den Index seines ersten Auftretens zurück.Searches for the specified object in a range of elements of a one-dimensional array, and returns the index of its first occurrence. Der Bereich erstreckt sich von einem angegebenen Index bis zum Ende des Arrays.The range extends from a specified index to the end of the array.

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.Searches for the specified object in a range of elements of a one-dimensional array, and returns the index of ifs first occurrence. Der Bereich erstreckt sich von einem angegebenen Index für eine angegebene Anzahl von Elementen.The range extends from a specified index for a specified number of elements.

IndexOf<T>(T[], T)

Sucht nach dem angegebenen Objekt und gibt den Index des ersten Vorkommens in einem eindimensionalen Array zurück.Searches for the specified object and returns the index of its first occurrence in a one-dimensional array.

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.Searches for the specified object in a range of elements of a one dimensional array, and returns the index of its first occurrence. Der Bereich erstreckt sich von einem angegebenen Index bis zum Ende des Arrays.The range extends from a specified index to the end of the array.

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.Searches for the specified object in a range of elements of a one-dimensional array, and returns the index of its first occurrence. Der Bereich erstreckt sich von einem angegebenen Index für eine angegebene Anzahl von Elementen.The range extends from a specified index for a specified number of elements.

Initialize()

Initialisiert jedes Element des Werttyp-Array durch einen Aufruf des parameterlosen Konstruktors für den Werttyp.Initializes every element of the value-type Array by calling the parameterless constructor of the value type.

LastIndexOf(Array, Object)

Sucht nach dem angegebenen Objekt und gibt den Index des letzten Vorkommens innerhalb des gesamten eindimensionalen Array zurück.Searches for the specified object and returns the index of the last occurrence within the entire one-dimensional Array.

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, der sich vom ersten Element bis zum angegebenen Index erstreckt.Searches for the specified object and returns the index of the last occurrence within the range of elements in the one-dimensional Array that extends from the first element to the specified index.

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, der die angegebene Anzahl von Elementen enthält und am angegebenen Index endet.Searches for the specified object and returns the index of the last occurrence within the range of elements in the one-dimensional Array that contains the specified number of elements and ends at the specified index.

LastIndexOf<T>(T[], T)

Sucht nach dem angegebenen Objekt und gibt den Index des letzten Vorkommens innerhalb des gesamten Array zurück.Searches for the specified object and returns the index of the last occurrence within the entire Array.

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

Sucht nach dem angegebenen Objekt und gibt den Index des letzten Vorkommens innerhalb des Bereichs von Elementen im Array zurück, der sich vom ersten Element bis zum angegebenen Index erstreckt.Searches for the specified object and returns the index of the last occurrence within the range of elements in the Array that extends from the first element to the specified index.

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, der die angegebene Anzahl von Elementen enthält und am angegebenen Index endet.Searches for the specified object and returns the index of the last occurrence within the range of elements in the Array that contains the specified number of elements and ends at the specified index.

MemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.Creates a shallow copy of the current Object.

(Geerbt von Object)
Resize<T>(T[], Int32)

Ändert die Anzahl der Elemente eines eindimensionalen Arrays in die angegebene neue Größe.Changes the number of elements of a one-dimensional array to the specified new size.

Reverse(Array)

Kehrt die Reihenfolge der Elemente im gesamten eindimensionalen Array um.Reverses the sequence of the elements in the entire one-dimensional Array.

Reverse(Array, Int32, Int32)

Kehrt die Reihenfolge der Elemente in einem Bereich von Elementen im eindimensionalen Array um.Reverses the sequence of the elements in a range of elements in the one-dimensional Array.

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

Legt das Element an der angegebenen Position des eindimensionalen Array auf einen Wert fest.Sets a value to the element at the specified position in the one-dimensional Array. Der Index wird als 32-Bit-Ganzzahl angegeben.The index is specified as a 32-bit integer.

SetValue(Object, Int32, Int32)

Legt das Element an der angegebenen Position des zweidimensionalen Array auf einen Wert fest.Sets a value to the element at the specified position in the two-dimensional Array. Die Indizes werden als 32-Bit-Ganzzahlen angegeben.The indexes are specified as 32-bit integers.

SetValue(Object, Int32, Int32, Int32)

Legt einen Wert auf das Element an der angegebenen Position im dreidimensionalen Array fest.Sets a value to the element at the specified position in the three-dimensional Array. Die Indizes werden als 32-Bit-Ganzzahlen angegeben.The indexes are specified as 32-bit integers.

SetValue(Object, Int32[])

Legt das Element an der angegebenen Position des mehrdimensionalen Array auf einen Wert fest.Sets a value to the element at the specified position in the multidimensional Array. Die Indizes werden als ein Array von 32-Bit-Ganzzahlen angegeben.The indexes are specified as an array of 32-bit integers.

SetValue(Object, Int64)

Legt das Element an der angegebenen Position des eindimensionalen Array auf einen Wert fest.Sets a value to the element at the specified position in the one-dimensional Array. Der Index wird als 64-Bit-Ganzzahl angegeben.The index is specified as a 64-bit integer.

SetValue(Object, Int64, Int64)

Legt das Element an der angegebenen Position des zweidimensionalen Array auf einen Wert fest.Sets a value to the element at the specified position in the two-dimensional Array. Die Indizes werden als 64-Bit-Ganzzahlen angegeben.The indexes are specified as 64-bit integers.

SetValue(Object, Int64, Int64, Int64)

Legt das Element an der angegebenen Position des dreidimensionalen Array auf einen Wert fest.Sets a value to the element at the specified position in the three-dimensional Array. Die Indizes werden als 64-Bit-Ganzzahlen angegeben.The indexes are specified as 64-bit integers.

SetValue(Object, Int64[])

Legt das Element an der angegebenen Position des mehrdimensionalen Array auf einen Wert fest.Sets a value to the element at the specified position in the multidimensional Array. Die Indizes werden als Array von 64-Bit-Ganzzahlen angegeben.The indexes are specified as an array of 64-bit integers.

Sort(Array)

Sortiert die Elemente in einem ganzen eindimensionalen Array mithilfe der IComparable-Implementierung jedes Elements des Array.Sorts the elements in an entire one-dimensional Array using the IComparable implementation of each element of the 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.Sorts a pair of one-dimensional Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the IComparable implementation of each key.

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.Sorts a pair of one-dimensional Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the specified 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.Sorts a range of elements in a pair of one-dimensional Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the IComparable implementation of each key.

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.Sorts a range of elements in a pair of one-dimensional Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the specified IComparer.

Sort(Array, IComparer)

Sortiert die Elemente in einem eindimensionalen Array mithilfe des angegebenen IComparer.Sorts the elements in a one-dimensional Array using the specified 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.Sorts the elements in a range of elements in a one-dimensional Array using the IComparable implementation of each element of the Array.

Sort(Array, Int32, Int32, IComparer)

Sortiert die Elemente in einem Bereich von Elementen in einem eindimensionalen Array mithilfe des angegebenen IComparer.Sorts the elements in a range of elements in a one-dimensional Array using the specified IComparer.

Sort<T>(T[])

Sortiert die Elemente in einem ganzen Array mithilfe der Implementierung der generischen IComparable<T>-Schnittstelle jedes Elements des Array.Sorts the elements in an entire Array using the IComparable<T> generic interface implementation of each element of the Array.

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

Sortiert die Elemente in einem Array mithilfe des angegebenen Comparison<T>.Sorts the elements in an Array using the specified Comparison<T>.

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

Sortiert die Elemente in einem Array mithilfe der angegebenen generischen IComparer<T>-Schnittstelle.Sorts the elements in an Array using the specified IComparer<T> generic interface.

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.Sorts the elements in a range of elements in an Array using the IComparable<T> generic interface implementation of each element of the 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.Sorts the elements in a range of elements in an Array using the specified IComparer<T> generic interface.

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.Sorts a pair of Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the IComparable<T> generic interface implementation of each key.

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.Sorts a pair of Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the specified IComparer<T> generic interface.

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.Sorts a range of elements in a pair of Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the IComparable<T> generic interface implementation of each key.

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.Sorts a range of elements in a pair of Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the specified IComparer<T> generic interface.

ToString()

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt.Returns a string that represents the current object.

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

Bestimmt, ob jedes Element im Array die vom angegebenen Prädikat definierten Bedingungen erfüllt.Determines whether every element in the array matches the conditions defined by the specified predicate.

Explizite Schnittstellenimplementierungen

ICollection.Count

Ruft die Anzahl der Elemente ab, die in Array enthalten sind.Gets the number of elements contained in the Array.

ICollection.IsSynchronized

Ruft einen Wert ab, der angibt, ob der Zugriff auf Array synchronisiert (threadsicher) ist.Gets a value that indicates whether access to the Array is synchronized (thread safe).

ICollection.SyncRoot

Ruft ein Objekt ab, mit dem der Zugriff auf Array synchronisiert werden kann.Gets an object that can be used to synchronize access to the Array.

IList.Add(Object)

Beim Aufrufen dieser Methode wird immer eine NotSupportedException-Ausnahme ausgelöst.Calling this method always throws a NotSupportedException exception.

IList.Clear()

Entfernt alle Elemente aus IList.Removes all items from the IList.

IList.Contains(Object)

Bestimmt, ob sich ein Element in IList befindet.Determines whether an element is in the IList.

IList.IndexOf(Object)

Bestimmt den Index eines bestimmten Elements in der IList.Determines the index of a specific item in the IList.

IList.Insert(Int32, Object)

Fügt am angegebenen Index ein Element in die IList ein.Inserts an item to the IList at the specified index.

IList.IsFixedSize

Ruft einen Wert ab, der angibt, ob die Array eine feste Größe hat.Gets a value that indicates whether the Array has a fixed size.

IList.IsReadOnly

Ruft einen Wert ab, der angibt, ob die Array schreibgeschützt ist.Gets a value that indicates whether the Array is read-only.

IList.Item[Int32]

Ruft das Element am angegebenen Index ab oder legt dieses fest.Gets or sets the element at the specified index.

IList.Remove(Object)

Entfernt das erste Vorkommen eines angegebenen Objekts aus der IList.Removes the first occurrence of a specific object from the IList.

IList.RemoveAt(Int32)

Entfernt das IList-Element am angegebenen Index.Removes the IList item at the specified index.

IStructuralComparable.CompareTo(Object, IComparer)

Bestimmt, ob das aktuelle Auflistungsobjekt in der Sortierreihenfolge vor oder nach einem anderen Objekt oder an derselben Position auftritt.Determines whether the current collection object precedes, occurs in the same position as, or follows another object in the sort order.

IStructuralEquatable.Equals(Object, IEqualityComparer)

Bestimmt, ob ein Objekt gleich der aktuellen Instanz ist.Determines whether an object is equal to the current instance.

IStructuralEquatable.GetHashCode(IEqualityComparer)

Gibt einen Hashcode für die aktuelle Instanz zurück.Returns a hash code for the current instance.

Erweiterungsmethoden

Cast<TResult>(IEnumerable)

Wandelt die Elemente eines IEnumerable in den angegebenen Typ umCasts the elements of an IEnumerable to the specified type.

OfType<TResult>(IEnumerable)

Filtert die Elemente eines IEnumerable anhand eines angegebenen TypsFilters the elements of an IEnumerable based on a specified type.

AsParallel(IEnumerable)

Ermöglicht die Parallelisierung einer Abfrage.Enables parallelization of a query.

AsQueryable(IEnumerable)

Konvertiert einen IEnumerable in einen IQueryable.Converts an IEnumerable to an IQueryable.

Gilt für:

Threadsicherheit

Öffentliche statische (Shared in Visual Basic) Member dieses Typs sind Thread sicher.Public static (Shared in Visual Basic) members of this type are thread safe. Bei Instanzmembern ist die Threadsicherheit nicht gewährleistet.Any instance members are not guaranteed to be thread safe.

Diese Implementierung stellt keinen synchronisierten (Thread sicheren) Wrapper für eine Arraybereit. .NET Framework Klassen, die auf Array basieren, bieten jedoch eine eigene synchronisierte Version der Auflistung mithilfe der SyncRoot-Eigenschaft.This implementation does not provide a synchronized (thread safe) wrapper for an Array; however, .NET Framework classes based on Array provide their own synchronized version of the collection using the SyncRoot property.

Die Enumeration einer Auflistung ist systemintern keine threadsichere Prozedur.Enumerating through a collection is intrinsically not a thread-safe procedure. 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.Even when a collection is synchronized, other threads can still modify the collection, which causes the enumerator to throw an exception. 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.To guarantee thread safety during enumeration, you can either lock the collection during the entire enumeration or catch the exceptions resulting from changes made by other threads.

Siehe auch