GetUpperBound() and GetLowerBound() function for array

Question

Can anyone please tell what does the two functions do? They take an integer argument which is told to be dimension. But how does the value of this integer changes the output?

Answer 1

The integer parameter to GetUpper/LowerBound() specifies the dimension.

Some examples:

// One-dimensional array
var oneD = new object[5];
Console.WriteLine("Dimension 0 Lower bound: {0}", oneD.GetLowerBound(0)) // Outputs "Dimension 0 Lower bound: 0"
Console.WriteLine("Dimension 0 Upper bound: {0}", oneD.GetUpperBound(0)) // Outputs "Dimension 0 Upper bound: 4"

// Two-dimensional array
var twoD = new object[5,10];
Console.WriteLine("Dimension 0 Lower bound: {0}", twoD.GetLowerBound(0)) // Outputs "Lower bound: 0"
Console.WriteLine("Dimension 0 Upper bound: {0}", twoD.GetUpperBound(0)) // Outputs "Upper bound: 4"
Console.WriteLine("Dimension 1 Lower bound: {0}", twoD.GetLowerBound(1)) // Outputs "Lower bound: 0"
Console.WriteLine("Dimension 1 Upper bound: {0}", twoD.GetUpperBound(1)) // Outputs "Upper bound: 9"

Whilst arrays defined within C# have lower bound = 0 and upper bound = length - 1, arrays from other sources (e.g. COM interop) can have different bounds, so those working with Excel interop for example will be familiar with arrays that have lower bound = 1, upper bound = length.

Answer 2

Can anyone please tell what does the two functions do?

It is written in their MSDN pages. They gets the index of the first / last element of the specified dimension in the array. Take a look Array.GetUpperBound and Array.GetLowerBound

They take an integer argument which is told to be dimension.

Yes, as Patashu mentioned, arrays can have multidimension.

Any idea why GetLowerBound() is always returning 0? If this always returns 0 then why do we need to call this method?

In an array, every dimension can have their specific lower and uppor bounds. So, this methods can create different results for each dimension of array.

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. Such arrays can be created with the CreateInstance(Type, Int32\[\], Int32\[\]) method, and can also be returned from unmanaged code.

Check out;

• Workaround: Arrays with non-zero lower bounds
• How to: Specify a Zero Lower Bound on an Array

Answer 3

May be some examples make the topic clear for you

We use GetUpperBound() to find out the upper bound of an array for given dimension, like that:

  int[,,] A = new int[7, 9, 11];
  // Returns 6: 0th dimension has 7 items, and so upper bound is 7 - 1 = 6;
  int upper0 = A.GetUpperBound(0); 
  // Returns 8: 0th dimension has 7 items, 1st - 9 and so upper bound is 9 - 1 = 8;
  int upper1 = A.GetUpperBound(1); 
  // Returns 10: 0th dimension has 7 items, 1st - 9, 2nd - 11 and so upper bound is 11 - 1 = 10;
  int upper2 = A.GetUpperBound(2); 

usually, GetLowerBound() returns 0, since arrays are zero-based by default, but in some rare cases they are not:

  // A is [17..21] array: 5 items starting from 17
  Array A = Array.CreateInstance(typeof(int), new int[] { 5 }, new int[] { 17 });
  // Returns 17
  int lower = A.GetLowerBound(0); 
  // Returns 21
  int upper = A.GetUpperBound(0); 

Typical loop using GetLowerBound and GetUpperBound is

  int[] A = ...

  for(int i = A.GetLowerBound(0); i <= A.GetUpperBound(0); ++i) {
    int item = A[i];
    ...
  }

  // ... or multidimension

  int[,,] A = ...;

  for (int i = A.GetLowerBound(0); i <= A.GetUpperBound(0); ++i)
    for (int j = A.GetLowerBound(1); j <= A.GetUpperBound(1); ++j)
      for (int k = A.GetLowerBound(2); k <= A.GetUpperBound(2); ++k) {
        int item = A[i, j, k];
        ...
      }