# Array.GetLowerBound(Int32) Méthode

## Définition

Obtient l'index du premier élément de la dimension spécifiée dans le tableau.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``

#### Paramètres

dimension
Int32

Dimension de base zéro du tableau dont l'index de départ doit être déterminé.A zero-based dimension of the array whose starting index needs to be determined.

#### Retours

Index du premier élément de la dimension spécifiée dans le tableau.The index of the first element of the specified dimension in the array.

#### Exceptions

`dimension` est inférieur à zéro.`dimension` is less than zero.

-ou--or- `dimension` est supérieur ou égal à Rank.`dimension` is equal to or greater than Rank.

## Exemples

L’exemple suivant utilise les méthodes GetLowerBound et GetUpperBound pour afficher les limites d’un tableau unidimensionnel et à deux dimensions et pour afficher les valeurs de leurs éléments de tableau.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
``````

## Remarques

`GetLowerBound(0)` retourne l’index de départ de la première dimension du tableau, et `GetLowerBound(Rank - 1)` retourne l’index de départ de la dernière dimension du tableau.`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.

La méthode GetLowerBound retourne toujours une valeur qui indique l’index de la limite inférieure du tableau, même si le tableau est vide.The GetLowerBound method always returns a value that indicates the index of the lower bound of the array, even if the array is empty.

Notez que, bien que la plupart des tableaux du .NET Framework soient de base zéro (autrement dit, la méthode GetLowerBound retourne zéro pour chaque dimension d’un tableau), le .NET Framework prend en charge les tableaux qui ne sont pas de base zéro.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. Ces tableaux peuvent être créés avec la méthode CreateInstance(Type, Int32[], Int32[]) et peuvent également être retournés à partir du code non managé.Such arrays can be created with the CreateInstance(Type, Int32[], Int32[]) method, and can also be returned from unmanaged code.

Cette méthode est une opération O (1).This method is an O(1) operation.