Array Array Array Array Class

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)]
[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
ArrayArrayArrayArray
Attribute
ComVisibleAttribute SerializableAttribute
Implementiert

Beispiele

Im folgenden Codebeispiel wird veranschaulicht, wie Array.Copy kopiert die Elemente zwischen einem Array vom typinteger und ein Array vom Typ Object.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 erstellt und initialisiert ein Array und zeigt die Eigenschaften und Elemente.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
 */
using System;
public class SamplesArray2{
 
    public static void Main()  {
 
       // 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 );
    }
 
 
    public static 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 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. Allerdings es dennoch als eine Sammlung, da er basiert die IList Schnittstelle.However, it is still considered a collection because it is based on the IList interface.

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

Ein Element ist ein Wert in eine Array.An element is a value in an Array. Die Länge einer Array ist die Gesamtzahl der Elemente, die es 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 können untere Grenze, aber es wurde eine Untergrenze von 0 (null), wird standardmäßig.An Array can have any lower bound, but it has a lower bound of zero by default. Eine andere Untergrenze definiert werden können, beim Erstellen einer Instanz von der Array -Klasse unter Verwendung CreateInstance. Ein mehrdimensionales Array haben verschiedene Grenzen für jede Dimension.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 der System.Collections Namespaces Array hat eine feste 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 erstellen Array Objekt mit der erforderlichen Kapazität, kopieren Sie die Elemente aus der alten Array Objekt in das neue Projekt, und löschen die alte Array.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.

Standardmäßig ist die maximale Größe einer Array beträgt 2 Gigabyte (GB).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 die enabled Attribut der GcAllowVeryLargeObjects Konfigurationselement, true in der Runtime-Umgebung.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. Das Array wird jedoch immer noch auf maximal 4 Milliarden-Elemente, und klicken Sie auf eine maximale Index 0X7FEFFFFF in einer beliebigen angegebenen Dimension (für Bytearrays und Arrays von einzelbytestrukturen 0X7FFFFFC7) beschränkt sein.However, the array will still be 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).

Eindimensionale Arrays implementieren die System.Collections.Generic.IList<T>, System.Collections.Generic.ICollection<T>, System.Collections.Generic.IEnumerable<T>, System.Collections.Generic.IReadOnlyList<T> und System.Collections.Generic.IReadOnlyCollection<T> generische Schnittstellen.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 für Arrays zur Laufzeit bereitgestellt werden, und die generischen Schnittstellen werden daher nicht angezeigt, in die Deklarationssyntax für die Array Klasse.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. Darüber hinaus stehen keine Referenzthemen für Schnittstellenmember, die nur durch das Umwandeln von ein Array, das den Typ der generischen Schnittstelle (explizite schnittstellenimplementierungen) 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). Der wichtigste Punkt zu beachten, wenn Sie ein Array, das eine dieser Schnittstellen umgewandelt wird, dass Mitglieder hinzufügen, einfügen oder Entfernen von Elementen Throw NotSupportedException.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 Informationen zum Typ Arraydeklarationen bereitgestellt-Objekten.Type objects provide information about array type declarations. Array Objekte mit dem gleichen Arraytyp verwenden dieselbe Type Objekt.Array objects with the same array type share the same Type object.

Type.IsArray und Type.GetElementType möglicherweise nicht die erwarteten Ergebnisse mit zurück Array da ein Array in den Typ umgewandelt wird Array, das Ergebnis ist ein Objekt, das nicht in ein Array.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. D. h. typeof(System.Array).IsArray gibt false, und typeof(System.Array).GetElementType gibt null.That is, typeof(System.Array).IsArray returns false, and typeof(System.Array).GetElementType returns null.

Die Array.Copy Methode kopiert die Elemente nicht nur zwischen Arrays des gleichen Typs, sondern auch zwischen verschiedenen Standardarrays; Typumwandlung von Elementen automatisch behandelt.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, wie z. B. CreateInstance, Copy, CopyTo, GetValue, und SetValue, stellen Überladungen, die 64-Bit-Ganzzahlen als Parameter für hohe Kapazitäten Arrays gerecht zu 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 64-Bit-Ganzzahlen, die die Länge des Arrays zurück.LongLength and GetLongLength return 64-bit integers indicating the length of the array.

Die Array ist nicht unbedingt sortiert werden.The Array is not guaranteed to be sorted. Sie sortieren, müssen die Array vor dem Ausführen von Vorgängen (z. B. BinarySearch), erfordern die Array sortiert werden soll.You must sort the Array prior to performing operations (such as BinarySearch) that require the Array to be sorted.

Verwenden einer Array Objekt von Zeigern in systemeigenem Code wird nicht unterstützt und löst eine NotSupportedException für einige Methoden.Using an Array object of pointers in native code is not supported and will throw a NotSupportedException for several methods.

Eigenschaften

IsFixedSize IsFixedSize IsFixedSize 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 IsReadOnly IsReadOnly IsReadOnly

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

IsSynchronized IsSynchronized IsSynchronized 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 Length Length 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 LongLength LongLength 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 Rank Rank Rank

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

SyncRoot SyncRoot SyncRoot 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[]) AsReadOnly<T>(T[]) AsReadOnly<T>(T[]) 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) BinarySearch(Array, Int32, Int32, Object) BinarySearch(Array, Int32, Int32, Object) 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) BinarySearch(Array, Int32, Int32, Object, IComparer) BinarySearch(Array, Int32, Int32, Object, IComparer) 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) BinarySearch(Array, Object) BinarySearch(Array, Object) 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) BinarySearch(Array, Object, IComparer) BinarySearch(Array, Object, IComparer) 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) BinarySearch<T>(T[], Int32, Int32, T) BinarySearch<T>(T[], Int32, Int32, T) 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>) BinarySearch<T>(T[], Int32, Int32, T, IComparer<T>) BinarySearch<T>(T[], Int32, Int32, T, IComparer<T>) 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) BinarySearch<T>(T[], T) BinarySearch<T>(T[], T) 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>) BinarySearch<T>(T[], T, IComparer<T>) BinarySearch<T>(T[], T, IComparer<T>) 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) Clear(Array, Int32, Int32) Clear(Array, Int32, Int32) 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() Clone() Clone() Clone()

Erstellt eine flache Kopie von Array. Creates a shallow copy of the Array.

ConstrainedCopy(Array, Int32, Array, Int32, Int32) ConstrainedCopy(Array, Int32, Array, Int32, Int32) ConstrainedCopy(Array, Int32, Array, Int32, Int32) 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>) ConvertAll<TInput,TOutput>(TInput[], Converter<TInput,TOutput>) ConvertAll<TInput,TOutput>(TInput[], Converter<TInput,TOutput>) 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) Copy(Array, Array, Int32) Copy(Array, Array, Int32) 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) Copy(Array, Array, Int64) Copy(Array, Array, Int64) 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) Copy(Array, Int32, Array, Int32, Int32) Copy(Array, Int32, Array, Int32, Int32) 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) Copy(Array, Int64, Array, Int64, Int64) Copy(Array, Int64, Array, Int64, Int64) 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) CopyTo(Array, Int32) CopyTo(Array, Int32) 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) CopyTo(Array, Int64) CopyTo(Array, Int64) 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) CreateInstance(Type, Int32) CreateInstance(Type, Int32) 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) CreateInstance(Type, Int32, Int32) CreateInstance(Type, Int32, Int32) 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) CreateInstance(Type, Int32, Int32, Int32) CreateInstance(Type, Int32, Int32, Int32) 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[]) CreateInstance(Type, Int32[]) CreateInstance(Type, Int32[]) 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[]) CreateInstance(Type, Int32[], Int32[]) CreateInstance(Type, Int32[], Int32[]) 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[]) CreateInstance(Type, Int64[]) CreateInstance(Type, Int64[]) 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>() Empty<T>() Empty<T>() Empty<T>()

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

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Bestimmt, ob das angegebene Objekt mit dem aktuellen Objekt identisch ist. Determines whether the specified object is equal to the current object.

(Inherited from Object)
Exists<T>(T[], Predicate<T>) Exists<T>(T[], Predicate<T>) Exists<T>(T[], Predicate<T>) 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) Fill<T>(T[], T) Fill<T>(T[], T) Fill<T>(T[], T)
Fill<T>(T[], T, Int32, Int32) Fill<T>(T[], T, Int32, Int32) Fill<T>(T[], T, Int32, Int32) Fill<T>(T[], T, Int32, Int32)
Find<T>(T[], Predicate<T>) Find<T>(T[], Predicate<T>) Find<T>(T[], Predicate<T>) 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>) FindAll<T>(T[], Predicate<T>) FindAll<T>(T[], Predicate<T>) 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>) FindIndex<T>(T[], Int32, Int32, Predicate<T>) FindIndex<T>(T[], Int32, Int32, Predicate<T>) 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>) FindIndex<T>(T[], Int32, Predicate<T>) FindIndex<T>(T[], Int32, Predicate<T>) 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>) FindIndex<T>(T[], Predicate<T>) FindIndex<T>(T[], Predicate<T>) 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>) FindLast<T>(T[], Predicate<T>) FindLast<T>(T[], Predicate<T>) 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>) FindLastIndex<T>(T[], Int32, Int32, Predicate<T>) FindLastIndex<T>(T[], Int32, Int32, Predicate<T>) 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>) FindLastIndex<T>(T[], Int32, Predicate<T>) FindLastIndex<T>(T[], Int32, Predicate<T>) 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>) FindLastIndex<T>(T[], Predicate<T>) FindLastIndex<T>(T[], Predicate<T>) 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>) ForEach<T>(T[], Action<T>) ForEach<T>(T[], Action<T>) 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() GetEnumerator() GetEnumerator() GetEnumerator()

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

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Fungiert als die Standardhashfunktion. Serves as the default hash function.

(Inherited from Object)
GetLength(Int32) GetLength(Int32) GetLength(Int32) 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) GetLongLength(Int32) GetLongLength(Int32) 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) GetLowerBound(Int32) GetLowerBound(Int32) 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() GetType() GetType() GetType()

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

(Inherited from Object)
GetUpperBound(Int32) GetUpperBound(Int32) GetUpperBound(Int32) 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) GetValue(Int32) GetValue(Int32) 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) GetValue(Int32, Int32) GetValue(Int32, Int32) 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) GetValue(Int32, Int32, Int32) GetValue(Int32, Int32, Int32) 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[]) GetValue(Int32[]) GetValue(Int32[]) 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) GetValue(Int64) GetValue(Int64) 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) GetValue(Int64, Int64) GetValue(Int64, Int64) 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) GetValue(Int64, Int64, Int64) GetValue(Int64, Int64, Int64) 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[]) GetValue(Int64[]) GetValue(Int64[]) 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 ein Array von 64-Bit-Ganzzahlen angegeben. The indexes are specified as an array of 64-bit integers.

IndexOf(Array, Object) IndexOf(Array, Object) IndexOf(Array, Object) 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) IndexOf(Array, Object, Int32) IndexOf(Array, Object, Int32) 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) IndexOf(Array, Object, Int32, Int32) IndexOf(Array, Object, Int32, Int32) 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) IndexOf<T>(T[], T) IndexOf<T>(T[], T) 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) IndexOf<T>(T[], T, Int32) IndexOf<T>(T[], T, Int32) 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) IndexOf<T>(T[], T, Int32, Int32) IndexOf<T>(T[], T, Int32, Int32) 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() Initialize() Initialize() Initialize()

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

LastIndexOf(Array, Object) LastIndexOf(Array, Object) LastIndexOf(Array, Object) 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) LastIndexOf(Array, Object, Int32) LastIndexOf(Array, Object, Int32) 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) LastIndexOf(Array, Object, Int32, Int32) LastIndexOf(Array, Object, Int32, Int32) 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) LastIndexOf<T>(T[], T) LastIndexOf<T>(T[], T) 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) LastIndexOf<T>(T[], T, Int32) LastIndexOf<T>(T[], T, Int32) 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) LastIndexOf<T>(T[], T, Int32, Int32) LastIndexOf<T>(T[], T, Int32, Int32) 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() MemberwiseClone() MemberwiseClone() MemberwiseClone()

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

(Inherited from Object)
Resize<T>(T[], Int32) Resize<T>(T[], Int32) Resize<T>(T[], Int32) 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) Reverse(Array) Reverse(Array) 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) Reverse(Array, Int32, Int32) Reverse(Array, Int32, Int32) 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[]) Reverse<T>(T[]) Reverse<T>(T[])
Reverse<T>(T[], Int32, Int32) Reverse<T>(T[], Int32, Int32) Reverse<T>(T[], Int32, Int32) Reverse<T>(T[], Int32, Int32)
SetValue(Object, Int32) SetValue(Object, Int32) SetValue(Object, 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) SetValue(Object, Int32, Int32) SetValue(Object, Int32, Int32) 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) SetValue(Object, Int32, Int32, Int32) SetValue(Object, Int32, Int32, Int32) SetValue(Object, Int32, Int32, Int32)

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 32-Bit-Ganzzahlen angegeben. The indexes are specified as 32-bit integers.

SetValue(Object, Int32[]) SetValue(Object, Int32[]) SetValue(Object, Int32[]) 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) SetValue(Object, Int64) SetValue(Object, Int64) 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) SetValue(Object, Int64, Int64) SetValue(Object, Int64, Int64) 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) SetValue(Object, Int64, Int64, Int64) SetValue(Object, Int64, Int64, Int64) 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[]) SetValue(Object, Int64[]) SetValue(Object, Int64[]) 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 ein Array von 64-Bit-Ganzzahlen angegeben. The indexes are specified as an array of 64-bit integers.

Sort(Array) Sort(Array) Sort(Array) 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) Sort(Array, Array) Sort(Array, Array) Sort(Array, Array)

Sortiert ein 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 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) Sort(Array, Array, IComparer) Sort(Array, Array, IComparer) Sort(Array, Array, IComparer)

Sortiert ein 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 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) Sort(Array, Array, Int32, Int32) Sort(Array, Array, Int32, Int32) 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) Sort(Array, Array, Int32, Int32, IComparer) Sort(Array, Array, Int32, Int32, IComparer) 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) Sort(Array, IComparer) Sort(Array, 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) Sort(Array, Int32, Int32) Sort(Array, Int32, Int32) 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) Sort(Array, Int32, Int32, IComparer) Sort(Array, Int32, Int32, IComparer) Sort(Array, Int32, Int32, IComparer)

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

Sort<T>(T[]) Sort<T>(T[]) Sort<T>(T[]) 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>) Sort<T>(T[], Comparison<T>) Sort<T>(T[], Comparison<T>) Sort<T>(T[], Comparison<T>)

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

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

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

Sort<T>(T[], Int32, Int32) Sort<T>(T[], Int32, Int32) Sort<T>(T[], Int32, Int32) 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>) Sort<T>(T[], Int32, Int32, IComparer<T>) Sort<T>(T[], Int32, Int32, IComparer<T>) Sort<T>(T[], Int32, Int32, IComparer<T>)

Sortiert die Elemente in einem Bereich von Elementen in der 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[]) Sort<TKey,TValue>(TKey[], TValue[]) Sort<TKey,TValue>(TKey[], TValue[]) 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>) Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) 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) Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32) Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32) 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>) Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) 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() ToString() ToString() ToString()

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

(Inherited from Object)
TrueForAll<T>(T[], Predicate<T>) TrueForAll<T>(T[], Predicate<T>) TrueForAll<T>(T[], Predicate<T>) 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 ICollection.Count ICollection.Count ICollection.Count

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

ICollection.IsSynchronized ICollection.IsSynchronized ICollection.IsSynchronized ICollection.IsSynchronized
ICollection.SyncRoot ICollection.SyncRoot ICollection.SyncRoot ICollection.SyncRoot
IList.Add(Object) IList.Add(Object) IList.Add(Object) IList.Add(Object)

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

IList.Clear() IList.Clear() IList.Clear() IList.Clear()

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

IList.Contains(Object) IList.Contains(Object) IList.Contains(Object) IList.Contains(Object)

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

IList.IndexOf(Object) IList.IndexOf(Object) IList.IndexOf(Object) 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) IList.Insert(Int32, Object) IList.Insert(Int32, Object) 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 IList.IsFixedSize IList.IsFixedSize IList.IsFixedSize
IList.IsReadOnly IList.IsReadOnly IList.IsReadOnly IList.IsReadOnly
IList.Item[Int32] IList.Item[Int32] IList.Item[Int32] 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) IList.Remove(Object) IList.Remove(Object) 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) IList.RemoveAt(Int32) IList.RemoveAt(Int32) IList.RemoveAt(Int32)

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

IStructuralComparable.CompareTo(Object, IComparer) IStructuralComparable.CompareTo(Object, IComparer) IStructuralComparable.CompareTo(Object, IComparer) 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) IStructuralEquatable.Equals(Object, IEqualityComparer) IStructuralEquatable.Equals(Object, IEqualityComparer) 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) IStructuralEquatable.GetHashCode(IEqualityComparer) IStructuralEquatable.GetHashCode(IEqualityComparer) IStructuralEquatable.GetHashCode(IEqualityComparer)

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

Gilt für:

Threadsicherheit

Öffentliche statische (Shared in Visual Basic) Member dieses Typs sind threadsicher. 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 bietet keinen synchronisierten (threadsicheren) Wrapper für ein Arrayjedoch .NET Framework-Klassen basierend auf Array Geben Sie ihre 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