Array.Reverse Method
Important
Some information relates to prerelease product that may be substantially modified before it’s released. Microsoft makes no warranties, express or implied, with respect to the information provided here.
| Reverse(Array) |
Reverses the sequence of the elements in the entire one-dimensional Array. |
| Reverse(Array, Int32, Int32) |
Reverses the sequence of a subset of the elements in the one-dimensional Array. |
| Reverse<T>(T[]) |
Reverses the sequence of the elements in the one-dimensional generic array. |
| Reverse<T>(T[], Int32, Int32) |
Reverses the sequence of a subset of the elements in the one-dimensional generic array. |
- Source:
- Array.cs
- Source:
- Array.cs
- Source:
- Array.cs
Reverses the sequence of the elements in the entire one-dimensional Array.
public:
static void Reverse(Array ^ array);C#
public static void Reverse(Array array);static member Reverse : Array -> unitPublic Shared Sub Reverse (array As Array)Parameters
Exceptions
array is null.
array is multidimensional.
Examples
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
*/
open System
let printIndexAndValues (arr: 'a []) =
for i = arr.GetLowerBound 0 to arr.GetUpperBound 0 do
printfn $"\t[{i}]:\t{arr[i]}"
// Creates and initializes a new Array.
let myArray =
[| "The"; "quick"; "brown"; "fox"
"jumps"; "over"; "the"; "lazy"; "dog" |]
// Displays the values of the Array.
printfn "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.
printfn "After reversing:"
printIndexAndValues myArray
(*
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
*)
C#
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
Remarks
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.
This method is an O(n) operation, where n is the Length of array.
In F#, the Array.rev function can be used instead.
As the following example shows, the Reverse method can be used to reverse a jagged array. It initializes a jagged array with one element for each month of the current year in the current culture's calendar. Each element contains an array with as many elements as that month has days. The example displays the contents of the array, calls the Reverse method, and then displays the contents of the reversed array.
C#
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
open System
open System.Globalization
let nMonths = DateTimeFormatInfo.CurrentInfo.Calendar.GetMonthsInYear DateTime.Now.Year
let months = Array.init nMonths (fun i ->
// Populate elements with number of days in month.
let daysInMonth = DateTime.DaysInMonth(DateTime.Now.Year, i + 1)
Array.init daysInMonth (fun i -> i + 1 ) )
for month in months do
for day in month do
printf $"{day} "
printfn ""
printfn "\nAbout to reverse array.\n"
Array.Reverse months
for month in months do
for day in month do
printf $"{day} "
printfn ""
// 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
// 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
// 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
Applies to
.NET 10 and other versions
| Product | Versions |
|---|---|
| .NET | Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9, 10 |
| .NET Framework | 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1 |
| .NET Standard | 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 2.0, 2.1 |
| UWP | 10.0 |
- Source:
- Array.cs
- Source:
- Array.cs
- Source:
- Array.cs
Reverses the sequence of a subset of the elements in the one-dimensional Array.
public:
static void Reverse(Array ^ array, int index, int length);C#
public static void Reverse(Array array, int index, int length);static member Reverse : Array * int * int -> unitPublic Shared Sub Reverse (array As Array, index As Integer, length As Integer)Parameters
- index
- Int32
The starting index of the section to reverse.
- length
- Int32
The number of elements in the section to reverse.
Exceptions
array is null.
array is multidimensional.
index is less than the lower bound of array.
-or-
length is less than zero.
index and length do not specify a valid range in array.
Examples
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
*/
open System
let printIndexAndValues (arr: 'a []) =
for i = arr.GetLowerBound 0 to arr.GetUpperBound 0 do
printfn $"\t[{i}]:\t{arr[i]}"
// Creates and initializes a new Array.
let myArray =
[| "The"; "QUICK"; "BROWN"; "FOX"
"jumps"; "over"; "the"; "lazy"; "dog" |]
// Displays the values of the Array.
printfn "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.
printfn "After reversing:"
printIndexAndValues myArray
(*
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
*)
C#
using System;
public class SamplesArray1 {
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
Remarks
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.
The Reverse method can be used to reverse a jagged array.
This method is an O(n) operation, where n is length.
Applies to
.NET 10 and other versions
| Product | Versions |
|---|---|
| .NET | Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9, 10 |
| .NET Framework | 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1 |
| .NET Standard | 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 2.0, 2.1 |
| UWP | 10.0 |
- Source:
- Array.cs
- Source:
- Array.cs
- Source:
- Array.cs
Reverses the sequence of the elements in the one-dimensional generic array.
public:
generic <typename T>
static void Reverse(cli::array <T> ^ array);C#
public static void Reverse<T>(T[] array);static member Reverse : 'T[] -> unitPublic Shared Sub Reverse(Of T) (array As T())Type Parameters
- T
The type of the elements in array.
Parameters
- array
- T[]
The one-dimensional array of elements to reverse.
Exceptions
array is null.
array is multidimensional.
Applies to
.NET 10 and other versions
| Product | Versions |
|---|---|
| .NET | Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9, 10 |
| .NET Standard | 2.1 |
- Source:
- Array.cs
- Source:
- Array.cs
- Source:
- Array.cs
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);C#
public static void Reverse<T>(T[] array, int index, int length);static member Reverse : 'T[] * int * int -> unitPublic Shared Sub Reverse(Of T) (array As T(), index As Integer, length As Integer)Type Parameters
- T
The type of the elements in array.
Parameters
- array
- T[]
The one-dimensional array of elements to reverse.
- index
- Int32
The starting index of the section to reverse.
- length
- Int32
The number of elements in the section to reverse.
Exceptions
array is null.
array is multidimensional.
index is less than the lower bound of array.
-or-
length is less than zero.
index and length do not specify a valid range in array.
Applies to
.NET 10 and other versions
| Product | Versions |
|---|---|
| .NET | Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9, 10 |
| .NET Standard | 2.1 |
Collaborate with us on GitHub
The source for this content can be found on GitHub, where you can also create and review issues and pull requests. For more information, see our contributor guide.
.NET feedback
.NET is an open source project. Select a link to provide feedback: