Array.Reverse Methode
Definition
Überlädt
Reverse(Array, Int32, Int32) |
Kehrt die Reihenfolge einer Teilmenge der Elemente im eindimensionalen Array um.Reverses the sequence of a subset of the elements in the one-dimensional 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<T>(T[]) |
Kehrt die Reihenfolge der Elemente im eindimensionalen generischen Array um.Reverses the sequence of the elements in the one-dimensional generic array. |
Reverse<T>(T[], Int32, Int32) |
Kehrt die Reihenfolge einer Teilmenge der Elemente im eindimensionalen generischen Array um.Reverses the sequence of a subset of the elements in the one-dimensional generic array. |
Reverse(Array, Int32, Int32)
public:
static void Reverse(Array ^ array, int index, int length);
public static void Reverse (Array array, int index, int length);
static member Reverse : Array * int * int -> unit
Public Shared Sub Reverse (array As Array, index As Integer, length As Integer)
Parameter
- index
- Int32
Der Startindex des umzukehrenden Abschnitts.The starting index of the section to reverse.
- length
- Int32
Die Anzahl der Elemente im umzukehrenden Abschnitt.The number of elements in the section to reverse.
Ausnahmen
array
ist null
.array
is null
.
array
ist mehrdimensional.array
is multidimensional.
index
ist kleiner als die untere array
-Grenze.index
is less than the lower bound of array
.
- oder --or-
length
ist kleiner als Null.length
is less than zero.
index
und length
geben keinen gültigen Bereich im array
an.index
and length
do not specify a valid range in array
.
Beispiele
Im folgenden Codebeispiel wird gezeigt, wie Sie die Sortierung der Werte in einem Bereich von Elementen in einem umkehren Array .The following code example shows how to reverse the sort of the values in a range of elements in an Array.
using namespace System;
void PrintIndexAndValues( Array^ myArray );
void main()
{
// Creates and initializes a new Array instance.
Array^ myArray = Array::CreateInstance( String::typeid, 9 );
myArray->SetValue( "The", 0 );
myArray->SetValue( "QUICK", 1 );
myArray->SetValue( "BROWN", 2 );
myArray->SetValue( "FOX", 3 );
myArray->SetValue( "jumps", 4 );
myArray->SetValue( "over", 5 );
myArray->SetValue( "the", 6 );
myArray->SetValue( "lazy", 7 );
myArray->SetValue( "dog", 8 );
// Displays the values of the Array.
Console::WriteLine( "The Array instance initially contains the following values:" );
PrintIndexAndValues( myArray );
// Reverses the sort of the values of the Array.
Array::Reverse( myArray, 1, 3 );
// Displays the values of the Array.
Console::WriteLine( "After reversing:" );
PrintIndexAndValues( myArray );
}
void PrintIndexAndValues( Array^ myArray )
{
for ( int i = myArray->GetLowerBound( 0 ); i <= myArray->GetUpperBound( 0 ); i++ )
Console::WriteLine( "\t[{0}]:\t{1}", i, myArray->GetValue( i ) );
}
/*
This code produces the following output.
The Array instance initially contains the following values:
[0]: The
[1]: QUICK
[2]: BROWN
[3]: FOX
[4]: jumps
[5]: over
[6]: the
[7]: lazy
[8]: dog
After reversing:
[0]: The
[1]: FOX
[2]: BROWN
[3]: QUICK
[4]: jumps
[5]: over
[6]: the
[7]: lazy
[8]: dog
*/
using System;
public class SamplesArray {
public static void Main() {
// Creates and initializes a new Array.
Array myArray=Array.CreateInstance( typeof(String), 9 );
myArray.SetValue( "The", 0 );
myArray.SetValue( "QUICK", 1 );
myArray.SetValue( "BROWN", 2 );
myArray.SetValue( "FOX", 3 );
myArray.SetValue( "jumps", 4 );
myArray.SetValue( "over", 5 );
myArray.SetValue( "the", 6 );
myArray.SetValue( "lazy", 7 );
myArray.SetValue( "dog", 8 );
// Displays the values of the Array.
Console.WriteLine( "The Array initially contains the following values:" );
PrintIndexAndValues( myArray );
// Reverses the sort of the values of the Array.
Array.Reverse( myArray, 1, 3 );
// Displays the values of the Array.
Console.WriteLine( "After reversing:" );
PrintIndexAndValues( myArray );
}
public static void PrintIndexAndValues( Array myArray ) {
for ( int i = myArray.GetLowerBound(0); i <= myArray.GetUpperBound(0); i++ )
Console.WriteLine( "\t[{0}]:\t{1}", i, myArray.GetValue( i ) );
}
}
/*
This code produces the following output.
The Array initially contains the following values:
[0]: The
[1]: QUICK
[2]: BROWN
[3]: FOX
[4]: jumps
[5]: over
[6]: the
[7]: lazy
[8]: dog
After reversing:
[0]: The
[1]: FOX
[2]: BROWN
[3]: QUICK
[4]: jumps
[5]: over
[6]: the
[7]: lazy
[8]: dog
*/
Public Class SamplesArray
Public Shared Sub Main()
' Creates and initializes a new Array.
Dim myArray As Array = Array.CreateInstance(GetType(String), 9)
myArray.SetValue("The", 0)
myArray.SetValue("QUICK", 1)
myArray.SetValue("BROWN", 2)
myArray.SetValue("FOX", 3)
myArray.SetValue("jumps", 4)
myArray.SetValue("over", 5)
myArray.SetValue("the", 6)
myArray.SetValue("lazy", 7)
myArray.SetValue("dog", 8)
' Displays the values of the Array.
Console.WriteLine("The Array initially contains the " _
+ "following values:")
PrintIndexAndValues(myArray)
' Reverses the sort of the values of the Array.
Array.Reverse(myArray, 1, 3)
' Displays the values of the Array.
Console.WriteLine("After reversing:")
PrintIndexAndValues(myArray)
End Sub
Public Shared Sub PrintIndexAndValues(myArray As Array)
Dim i As Integer
For i = myArray.GetLowerBound(0) To myArray.GetUpperBound(0)
Console.WriteLine(ControlChars.Tab + "[{0}]:" + ControlChars.Tab _
+ "{1}", i, myArray.GetValue(i))
Next i
End Sub
End Class
' This code produces the following output.
'
' The Array initially contains the following values:
' [0]: The
' [1]: QUICK
' [2]: BROWN
' [3]: FOX
' [4]: jumps
' [5]: over
' [6]: the
' [7]: lazy
' [8]: dog
' After reversing:
' [0]: The
' [1]: FOX
' [2]: BROWN
' [3]: QUICK
' [4]: jumps
' [5]: over
' [6]: the
' [7]: lazy
' [8]: dog
Hinweise
Nach einem Rückruf dieser Methode wird das-Element bei myArray[i]
, wobei i
ein beliebiger Index im-Array ist, zu verschoben myArray[j]
, wobei j
gleich ist (myArray.Length + myArray.GetLowerBound(0)) - (i - myArray.GetLowerBound(0)) - 1
.After a call to this method, the element at myArray[i]
, where i
is any index in the array, moves to myArray[j]
, where j
equals (myArray.Length + myArray.GetLowerBound(0)) - (i - myArray.GetLowerBound(0)) - 1
.
Die- Reverse Methode kann verwendet werden, um eine Jagged Array umzukehren.The Reverse method can be used to reverse a jagged array.
Diese Methode ist ein O ( n
)-Vorgang, bei dem gleich n
ist length
.This method is an O(n
) operation, where n
is length
.
Gilt für:
Reverse(Array)
public:
static void Reverse(Array ^ array);
public static void Reverse (Array array);
static member Reverse : Array -> unit
Public Shared Sub Reverse (array As Array)
Parameter
Ausnahmen
array
ist null
.array
is null
.
array
ist mehrdimensional.array
is multidimensional.
Beispiele
Im folgenden Codebeispiel wird gezeigt, wie Sie die Sortierung der Werte in umkehren Array .The following code example shows how to reverse the sort of the values in an Array.
using namespace System;
void PrintIndexAndValues( Array^ myArray );
void main()
{
// Creates and initializes a new Array instance.
Array^ myArray = Array::CreateInstance( String::typeid, 9 );
myArray->SetValue( "The", 0 );
myArray->SetValue( "quick", 1 );
myArray->SetValue( "brown", 2 );
myArray->SetValue( "fox", 3 );
myArray->SetValue( "jumps", 4 );
myArray->SetValue( "over", 5 );
myArray->SetValue( "the", 6 );
myArray->SetValue( "lazy", 7 );
myArray->SetValue( "dog", 8 );
// Displays the values of the Array.
Console::WriteLine( "The Array instance initially contains the following values:" );
PrintIndexAndValues( myArray );
// Reverses the sort of the values of the Array.
Array::Reverse( myArray );
// Displays the values of the Array.
Console::WriteLine( "After reversing:" );
PrintIndexAndValues( myArray );
}
void PrintIndexAndValues( Array^ myArray )
{
for ( int i = myArray->GetLowerBound( 0 ); i <= myArray->GetUpperBound( 0 ); i++ )
Console::WriteLine( "\t[{0}]:\t{1}", i, myArray->GetValue( i ) );
}
/*
This code produces the following output.
The Array instance initially contains the following values:
[0]: The
[1]: quick
[2]: brown
[3]: fox
[4]: jumps
[5]: over
[6]: the
[7]: lazy
[8]: dog
After reversing:
[0]: dog
[1]: lazy
[2]: the
[3]: over
[4]: jumps
[5]: fox
[6]: brown
[7]: quick
[8]: The
*/
using System;
public class SamplesArray {
public static void Main() {
// Creates and initializes a new Array.
Array myArray=Array.CreateInstance( typeof(String), 9 );
myArray.SetValue( "The", 0 );
myArray.SetValue( "quick", 1 );
myArray.SetValue( "brown", 2 );
myArray.SetValue( "fox", 3 );
myArray.SetValue( "jumps", 4 );
myArray.SetValue( "over", 5 );
myArray.SetValue( "the", 6 );
myArray.SetValue( "lazy", 7 );
myArray.SetValue( "dog", 8 );
// Displays the values of the Array.
Console.WriteLine( "The Array initially contains the following values:" );
PrintIndexAndValues( myArray );
// Reverses the sort of the values of the Array.
Array.Reverse( myArray );
// Displays the values of the Array.
Console.WriteLine( "After reversing:" );
PrintIndexAndValues( myArray );
}
public static void PrintIndexAndValues( Array myArray ) {
for ( int i = myArray.GetLowerBound(0); i <= myArray.GetUpperBound(0); i++ )
Console.WriteLine( "\t[{0}]:\t{1}", i, myArray.GetValue( i ) );
}
}
/*
This code produces the following output.
The Array initially contains the following values:
[0]: The
[1]: quick
[2]: brown
[3]: fox
[4]: jumps
[5]: over
[6]: the
[7]: lazy
[8]: dog
After reversing:
[0]: dog
[1]: lazy
[2]: the
[3]: over
[4]: jumps
[5]: fox
[6]: brown
[7]: quick
[8]: The
*/
Public Class SamplesArray
Public Shared Sub Main()
' Creates and initializes a new Array.
Dim myArray As Array = Array.CreateInstance(GetType(String), 9)
myArray.SetValue("The", 0)
myArray.SetValue("quick", 1)
myArray.SetValue("brown", 2)
myArray.SetValue("fox", 3)
myArray.SetValue("jumps", 4)
myArray.SetValue("over", 5)
myArray.SetValue("the", 6)
myArray.SetValue("lazy", 7)
myArray.SetValue("dog", 8)
' Displays the values of the Array.
Console.WriteLine("The Array initially contains the " _
+ "following values:")
PrintIndexAndValues(myArray)
' Reverses the sort of the values of the Array.
Array.Reverse(myArray)
' Displays the values of the Array.
Console.WriteLine("After reversing:")
PrintIndexAndValues(myArray)
End Sub
Public Shared Sub PrintIndexAndValues(myArray As Array)
Dim i As Integer
For i = myArray.GetLowerBound(0) To myArray.GetUpperBound(0)
Console.WriteLine(ControlChars.Tab + "[{0}]:" + ControlChars.Tab _
+ "{1}", i, myArray.GetValue(i))
Next i
End Sub
End Class
' This code produces the following output.
'
' The Array initially contains the following values:
' [0]: The
' [1]: quick
' [2]: brown
' [3]: fox
' [4]: jumps
' [5]: over
' [6]: the
' [7]: lazy
' [8]: dog
' After reversing:
' [0]: dog
' [1]: lazy
' [2]: the
' [3]: over
' [4]: jumps
' [5]: fox
' [6]: brown
' [7]: quick
' [8]: The
Hinweise
Nach einem Rückruf dieser Methode wird das-Element bei myArray[i]
, wobei i
ein beliebiger Index im-Array ist, zu verschoben myArray[j]
, wobei j
gleich ist (myArray.Length + myArray.GetLowerBound(0)) - (i - myArray.GetLowerBound(0)) - 1
.After a call to this method, the element at myArray[i]
, where i
is any index in the array, moves to myArray[j]
, where j
equals (myArray.Length + myArray.GetLowerBound(0)) - (i - myArray.GetLowerBound(0)) - 1
.
Bei dieser Methode handelt es sich um einen O ( n
)-Vorgang, wobei n
der Length von ist array
.This method is an O(n
) operation, where n
is the Length of array
.
Wie im folgenden Beispiel gezeigt, kann die- Reverse Methode verwendet werden, um eine Jagged Array umzukehren.As the following example shows, the Reverse method can be used to reverse a jagged array. Sie Initialisiert eine Jagged Array mit einem-Element für jeden Monat des aktuellen Jahres im Kalender der aktuellen Kultur.It initializes a jagged array with one element for each month of the current year in the current culture's calendar. Jedes-Element enthält ein Array mit so vielen Elementen, wie dieser Monat Tage hat.Each element contains an array with as many elements as that month has days. Das Beispiel zeigt den Inhalt des Arrays an, ruft die Reverse -Methode auf und zeigt dann den Inhalt des umgekehrten Arrays an.The example displays the contents of the array, calls the Reverse method, and then displays the contents of the reversed array.
using System;
using System.Globalization;
public class Example
{
public static void Main()
{
int nMonths = DateTimeFormatInfo.CurrentInfo.Calendar.GetMonthsInYear(DateTime.Now.Year);
int[][] months = new int[nMonths][];
// Populate elements with number of days in month.
for (int ctr = 0; ctr <= months.GetUpperBound(0); ctr++) {
int daysInMonth = DateTime.DaysInMonth(DateTime.Now.Year, ctr + 1);
months[ctr] = new int[daysInMonth] ;
for (int ctr2 = 1; ctr2 <= daysInMonth; ctr2++)
months[ctr][ctr2 - 1] = ctr2;
}
foreach (var month in months) {
foreach (var day in month)
Console.Write("{0} ", day);
Console.WriteLine();
}
Console.WriteLine();
Console.WriteLine("About to reverse array.\n");
Array.Reverse(months);
foreach (var month in months) {
foreach (var day in month)
Console.Write("{0} ", day);
Console.WriteLine();
}
}
}
// The example displays output similar to the following:
// 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
// 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29
// 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
// 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
// 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
// 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
// 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
// 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
// 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
// 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
// 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
// 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
//
// About to reverse array.
//
// 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
// 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
// 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
// 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
// 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
// 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
// 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
// 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
// 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
// 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
// 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29
// 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
Imports System.Globalization
Module Example
Public Sub Main()
Dim nMonths As Integer = DateTimeFormatInfo.CurrentInfo.Calendar.GetMonthsInYear(Date.Now.Year)
Dim months()() As Integer = New Integer(nMonths - 1)() {}
' Populate elements with number of days in month.
For ctr As Integer = 0 To months.GetUpperBound(0)
Dim daysInMonth As Integer = DateTime.DaysInMonth(Date.Now.Year, ctr + 1)
months(ctr) = New Integer(daysInMonth - 1) {}
For ctr2 As Integer = 1 To daysInMonth
months(ctr)(ctr2 - 1) = ctr2
Next
Next
For Each _month In months
For each _day In _month
Console.Write("{0} ", _day)
Next
Console.WriteLine()
Next
Console.WriteLine()
Console.WriteLine("About to reverse array.")
Console.WriteLine()
Array.Reverse(months)
For Each _month In months
For each _day In _month
Console.Write("{0} ", _day)
Next
Console.WriteLine()
Next
End Sub
End Module
' The example displays output similar to the following:
' 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
' 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29
' 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
' 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
' 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
' 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
' 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
' 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
' 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
' 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
' 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
' 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
'
' About to reverse array.
'
' 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
' 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
' 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
' 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
' 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
' 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
' 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
' 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
' 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
' 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
' 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29
' 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
Gilt für:
Reverse<T>(T[])
Kehrt die Reihenfolge der Elemente im eindimensionalen generischen Array um.Reverses the sequence of the elements in the one-dimensional generic array.
public:
generic <typename T>
static void Reverse(cli::array <T> ^ array);
public static void Reverse<T> (T[] array);
static member Reverse : 'T[] -> unit
Public Shared Sub Reverse(Of T) (array As T())
Typparameter
- T
Der Typ der Elemente in array
.The type of the elements in array
.
Parameter
- array
- T[]
Das umzukehrende eindimensionale Array von Elementen.The one-dimensional array of elements to reverse.
Ausnahmen
array
ist null
.array
is null
.
array
ist mehrdimensional.array
is multidimensional.
Gilt für:
Reverse<T>(T[], Int32, Int32)
Kehrt die Reihenfolge einer Teilmenge der Elemente im eindimensionalen generischen Array um.Reverses the sequence of a subset of the elements in the one-dimensional generic array.
public:
generic <typename T>
static void Reverse(cli::array <T> ^ array, int index, int length);
public static void Reverse<T> (T[] array, int index, int length);
static member Reverse : 'T[] * int * int -> unit
Public Shared Sub Reverse(Of T) (array As T(), index As Integer, length As Integer)
Typparameter
- T
Der Typ der Elemente in array
.The type of the elements in array
.
Parameter
- array
- T[]
Das umzukehrende eindimensionale Array von Elementen.The one-dimensional array of elements to reverse.
- index
- Int32
Der Startindex des umzukehrenden Abschnitts.The starting index of the section to reverse.
- length
- Int32
Die Anzahl der Elemente im umzukehrenden Abschnitt.The number of elements in the section to reverse.
Ausnahmen
array
ist null
.array
is null
.
array
ist mehrdimensional.array
is multidimensional.
index
ist kleiner als die untere array
-Grenze.index
is less than the lower bound of array
.
- oder --or-
length
ist kleiner als Null.length
is less than zero.
index
und length
geben keinen gültigen Bereich im array
an.index
and length
do not specify a valid range in array
.