# Array.GetLowerBound(Int32) メソッド

## 定義

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

dimension
Int32

Int32

#### 例外

`dimension` が 0 未満です。

または

`dimension`Rank 以上になっています。

## 例

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

## 注釈

`GetLowerBound(0)` は配列の最初の次元の開始インデックスを返し `GetLowerBound(Rank - 1)` 、配列の最後の次元の開始インデックスを返します。

このメソッドは GetLowerBound 、配列が空の場合でも、配列の下限のインデックスを示す値を常に返します。

.NET のほとんどの配列は 0 から始まりますが (つまり、メソッドは配列の各次元に対して 0 を返します)、 GetLowerBound .NET では 0 から始まらない配列がサポートされます。 このような配列は、メソッドを使用して CreateInstance(Type, Int32[], Int32[]) 作成でき、アンマネージ コードから返すこともできます。

このメソッドは、O(1) 操作です。