Array.GetLowerBound(Int32) Metodo

Definizione

Ottiene l'indice del primo elemento della dimensione specificata nella matrice.Gets the index of the first element of the specified dimension in the array.

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

Parametri

dimension
Int32

Dimensione in base zero della matrice di cui è necessario determinare l'indice iniziale.A zero-based dimension of the array whose starting index needs to be determined.

Restituisce

Indice del primo elemento della dimensione specificata nella matrice.The index of the first element of the specified dimension in the array.

Eccezioni

dimension è minore di zero.dimension is less than zero.

-oppure--or- dimension è uguale a o maggiore di Rank.dimension is equal to or greater than Rank.

Esempi

Nell'esempio seguente vengono usati i metodi GetLowerBound e GetUpperBound per visualizzare i limiti di una matrice unidimensionale e bidimensionale e per visualizzare i valori degli elementi della matrice.The following example uses the GetLowerBound and GetUpperBound methods to display the bounds of a one-dimensional and two-dimensional array and to display the values of their array elements.

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

Commenti

GetLowerBound(0) restituisce l'indice iniziale della prima dimensione della matrice e GetLowerBound(Rank - 1) restituisce l'indice iniziale dell'ultima dimensione della matrice.GetLowerBound(0) returns the starting index of the first dimension of the array, and GetLowerBound(Rank - 1) returns the starting index of the last dimension of the array.

Il metodo GetLowerBound restituisce sempre un valore che indica l'indice del limite inferiore della matrice, anche se la matrice è vuota.The GetLowerBound method always returns a value that indicates the index of the lower bound of the array, even if the array is empty.

Si noti che, anche se la maggior parte delle matrici nel .NET Framework sono in base zero, ovvero il metodo GetLowerBound restituisce zero per ogni dimensione di una matrice, il .NET Framework supporta matrici che non sono in base zero.Note that, although most arrays in the .NET Framework are zero-based (that is, the GetLowerBound method returns zero for each dimension of an array), the .NET Framework does support arrays that are not zero-based. Tali matrici possono essere create con il metodo CreateInstance(Type, Int32[], Int32[]) e possono essere restituite anche dal codice non gestito.Such arrays can be created with the CreateInstance(Type, Int32[], Int32[]) method, and can also be returned from unmanaged code.

Questo metodo è un'operazione O (1).This method is an O(1) operation.

Si applica a

Vedi anche