Freigeben über


Array.GetUpperBound(Int32) Methode

Definition

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

public:
 int GetUpperBound(int dimension);
public int GetUpperBound (int dimension);
member this.GetUpperBound : int -> int
Public Function GetUpperBound (dimension As Integer) As Integer

Parameter

dimension
Int32

Eine nullbasierte Dimension des Arrays, dessen obere Grenze bestimmt werden soll.

Gibt zurück

Int32

Der Index des letzten Elements in der angegebenen Dimension im Array oder -1, wenn die angegebene Dimension leer ist.

Ausnahmen

dimension ist kleiner als Null.

- oder -

dimension ist größer oder gleich Rank.

Beispiele

Im folgenden Beispiel werden die GetLowerBound GetUpperBound Grenzen eines eindimensionalen und zweidimensionalen Arrays und die Werte ihrer Arrayelemente angezeigt.

using namespace System;

void main()  
{
   // Create a one-dimensional integer array.
   array<int>^ integers = { 2, 4, 6, 8, 10, 12, 14, 16, 18, 20 };
   // Get the upper and lower bound of the array.
   int upper = integers->GetUpperBound(0);
   int lower = integers->GetLowerBound(0);
   Console::WriteLine("Elements from index {0} to {1}:", lower, upper);
   // Iterate the array.
   for (int ctr = lower; ctr <= upper; ctr++)
     Console::Write("{0}{1}{2}", ctr == lower ? "   " : "", 
                                 integers[ctr], 
                                 ctr < upper ? ", " : Environment::NewLine);

   Console::WriteLine();
   
   // Create a two-dimensional integer array.
   array<int, 2>^ integers2d = { {2, 4}, {3, 9}, {4, 16}, {5, 25}, 
                                 {6, 36}, {7, 49}, {8, 64}, {9, 81} }; 
   // Get the number of dimensions.                               
   int rank = integers2d->Rank;  
   Console::WriteLine("Number of dimensions: {0}", rank);      
   for (int ctr = 0; ctr < rank; ctr++)
     Console::WriteLine("   Dimension {0}: from {1} to {2}",
                        ctr, integers2d->GetLowerBound(ctr),
                        integers2d->GetUpperBound(ctr));

   // Iterate the 2-dimensional array and display its values.
   Console::WriteLine("   Values of array elements:");
   for (int outer = integers2d->GetLowerBound(0); outer <= integers2d->GetUpperBound(0);
        outer++)
     for (int inner = integers2d->GetLowerBound(1); inner <= integers2d->GetUpperBound(1);
          inner++)
        Console::WriteLine("      {3}{0}, {1}{4} = {2}", outer, inner,
                           integers2d->GetValue(outer, inner), "{", "}");
}
// The example displays the following output:
//       Elements from index 0 to 9:
//          2, 4, 6, 8, 10, 12, 14, 16, 18, 20
//       
//       Number of dimensions: 2
//          Dimension 0: from 0 to 7
//          Dimension 1: from 0 to 1
//          Values of array elements:
//             {0, 0} = 2
//             {0, 1} = 4
//             {1, 0} = 3
//             {1, 1} = 9
//             {2, 0} = 4
//             {2, 1} = 16
//             {3, 0} = 5
//             {3, 1} = 25
//             {4, 0} = 6
//             {4, 1} = 36
//             {5, 0} = 7
//             {5, 1} = 49
//             {6, 0} = 8
//             {6, 1} = 64
//             {7, 0} = 9
//             {7, 1} = 81
using System;

public class Example
{
   public static void Main()
   {
      // Create a one-dimensional integer array.
      int[] integers = { 2, 4, 6, 8, 10, 12, 14, 16, 18, 20 };
      // Get the upper and lower bound of the array.
      int upper = integers.GetUpperBound(0);
      int lower = integers.GetLowerBound(0);
      Console.WriteLine($"Elements from index {lower} to {upper}:");
      // Iterate the array.
      for (int ctr = lower; ctr <= upper; ctr++)
        Console.Write($"{(ctr == lower ?"   " : "")}{integers[ctr]}" +
                      $"{(ctr < upper ? ", " : Environment.NewLine)}");

      Console.WriteLine();

      // Create a two-dimensional integer array.
      int[,] integers2d= { {2, 4}, {3, 9}, {4, 16}, {5, 25},
                           {6, 36}, {7, 49}, {8, 64}, {9, 81} };
      // Get the number of dimensions.
      int rank = integers2d.Rank;
      Console.WriteLine($"Number of dimensions: {rank}");
      for (int ctr = 0; ctr < rank; ctr++)
        Console.WriteLine($"   Dimension {ctr}: " +
                          $"from {integers2d.GetLowerBound(ctr)} to {integers2d.GetUpperBound(ctr)}");

      // Iterate the 2-dimensional array and display its values.
      Console.WriteLine("   Values of array elements:");
      for (int outer = integers2d.GetLowerBound(0); outer <= integers2d.GetUpperBound(0);
           outer++)
        for (int inner = integers2d.GetLowerBound(1); inner <= integers2d.GetUpperBound(1);
             inner++)
           Console.WriteLine($"      {'\u007b'}{outer}, {inner}{'\u007d'} = " +
                             $"{integers2d.GetValue(outer, inner)}");
   }
}
// The example displays the following output:
//       Elements from index 0 to 9:
//          2, 4, 6, 8, 10, 12, 14, 16, 18, 20
//
//       Number of dimensions: 2
//          Dimension 0: from 0 to 7
//          Dimension 1: from 0 to 1
//          Values of array elements:
//             {0, 0} = 2
//             {0, 1} = 4
//             {1, 0} = 3
//             {1, 1} = 9
//             {2, 0} = 4
//             {2, 1} = 16
//             {3, 0} = 5
//             {3, 1} = 25
//             {4, 0} = 6
//             {4, 1} = 36
//             {5, 0} = 7
//             {5, 1} = 49
//             {6, 0} = 8
//             {6, 1} = 64
//             {7, 0} = 9
//             {7, 1} = 81
open System


// Create a one-dimensional integer array.
let integers = [| 2..2..20 |]

// Get the upper and lower bound of the array.
let upper = integers.GetUpperBound 0
let lower = integers.GetLowerBound 0
printfn $"Elements from index {lower} to {upper}:"

// Iterate the array.
for i = lower to upper do
    if i = lower then printf "   "
    printf $"{integers[i]}"
    if i < upper then ", " else Environment.NewLine
    |> printf "%s"

printfn ""

// Create a two-dimensional integer array.
let integers2d = 
    array2D [ [ 2; 4 ]; [ 3; 9 ]; [ 4; 16 ]; [ 5; 25 ]
              [ 6; 36 ]; [ 7; 49 ]; [ 8; 64 ]; [ 9; 81 ] ]

// Get the number of dimensions.
let rank = integers2d.Rank
printfn $"Number of dimensions: {rank}"
for i = 0 to rank - 1 do
    printfn $"   Dimension {i}: from {integers2d.GetLowerBound i} to {integers2d.GetUpperBound i}"

// Iterate the 2-dimensional array and display its values.
printfn "   Values of array elements:"
for outer = integers2d.GetLowerBound 0 to integers2d.GetUpperBound 0 do

    for inner = integers2d.GetLowerBound 1 to integers2d.GetUpperBound 1 do
        printfn $"      {'\u007b'}{outer}, {inner}{'\u007d'} = {integers2d.GetValue(outer, inner)}"
   
// The example displays the following output:
//       Elements from index 0 to 9:
//          2, 4, 6, 8, 10, 12, 14, 16, 18, 20
//
//       Number of dimensions: 2
//          Dimension 0: from 0 to 7
//          Dimension 1: from 0 to 1
//          Values of array elements:
//             {0, 0} = 2
//             {0, 1} = 4
//             {1, 0} = 3
//             {1, 1} = 9
//             {2, 0} = 4
//             {2, 1} = 16
//             {3, 0} = 5
//             {3, 1} = 25
//             {4, 0} = 6
//             {4, 1} = 36
//             {5, 0} = 7
//             {5, 1} = 49
//             {6, 0} = 8
//             {6, 1} = 64
//             {7, 0} = 9
//             {7, 1} = 81
Public Module Example    
    Public Sub Main()
        ' Create a one-dimensional integer array.
        Dim integers() As Integer = { 2, 4, 6, 8, 10, 12, 14, 16, 18, 20 }
        ' Get the upper and lower bound of the array.
        Dim upper As Integer = integers.GetUpperBound(0)
        Dim lower As Integer = integers.GetLowerBound(0)
        Console.WriteLine($"Elements from index {lower} to {upper}:")
        ' Iterate the array.
        For ctr As Integer = lower To upper
           Console.Write("{0}{1}{2}", If(ctr = lower, "   ", ""), 
                                     integers(ctr), 
                                     If(ctr < upper, ", ", vbCrLf))
        Next
        Console.WriteLine()
        
        ' Create a two-dimensional integer array.
        Dim integers2d(,) As Integer = {{2, 4}, {3, 9}, {4, 16}, {5, 25}, 
                                       {6, 36}, {7, 49}, {8, 64}, {9, 81} } 
        ' Get the number of dimensions.                               
        Dim rank As Integer = integers2d.Rank  
        Console.WriteLine($"Number of dimensions: {rank}")      
        For ctr As Integer = 0 To rank - 1
           Console.WriteLine($"   Dimension {ctr}: " +
                             $"from {integers2d.GetLowerBound(ctr)} to {integers2d.GetUpperBound(ctr)}")
        Next
        ' Iterate the 2-dimensional array and display its values.
        Console.WriteLine("   Values of array elements:")
        For outer = integers2d.GetLowerBound(0) To integers2d.GetUpperBound(0)
           For inner = integers2d.GetLowerBound(1) To integers2d.GetUpperBound(1)
              Console.WriteLine($"      {ChrW(&h07b)}{outer}, {inner}{ChrW(&h007d)} = " +
                                $"{integers2d.GetValue(outer, inner)}")
           Next
        Next
    End Sub
End Module
' The example displays the following output.
'       Elements from index 0 to 9:
'          2, 4, 6, 8, 10, 12, 14, 16, 18, 20
'       
'       Number of dimensions: 2
'          Dimension 0: from 0 to 7
'          Dimension 1: from 0 to 1
'          Values of array elements:
'             {0, 0} = 2
'             {0, 1} = 4
'             {1, 0} = 3
'             {1, 1} = 9
'             {2, 0} = 4
'             {2, 1} = 16
'             {3, 0} = 5
'             {3, 1} = 25
'             {4, 0} = 6
'             {4, 1} = 36
'             {5, 0} = 7
'             {5, 1} = 49
'             {6, 0} = 8
'             {6, 1} = 64
'             {7, 0} = 9
'             {7, 1} = 81

Hinweise

GetUpperBound(0) gibt den letzten Index in der ersten Dimension des Arrays zurück und GetUpperBound(Rank - 1) gibt den letzten Index der letzten Dimension des Arrays zurück.

Diese Methode ist ein O(1)-Vorgang.

Gilt für

Siehe auch