Array bounds checking behavior in C Sharp (C#)

Introduction

Array bounds checking helps prevent errors by making sure you don't access parts of an array that don't exist.

When you want to safely access elements in an array without crashing your program.

When you need to avoid bugs caused by using wrong index numbers.

When you want to understand why your program throws an error when accessing invalid array positions.

Syntax

C Sharp (C#)

class Program
{
    static void Main()
    {
        int[] numbers = new int[3];
        // Accessing elements within bounds
        int first = numbers[0];

        // Accessing elements outside bounds throws an exception
        int invalid = numbers[3]; // This causes an error
    }
}

C# automatically checks if the index is within the array size.

If you try to access an index less than 0 or greater than or equal to the array length, it throws an IndexOutOfRangeException.

Examples

Trying to access any element in an empty array causes an error because there are no valid indexes.

C Sharp (C#)

int[] emptyArray = new int[0];
// Accessing any element will throw an exception
int value = emptyArray[0];

Accessing the only valid index 0 works, but index 1 is out of bounds and causes an error.

C Sharp (C#)

int[] singleElementArray = { 42 };
int first = singleElementArray[0]; // Works fine
int invalid = singleElementArray[1]; // Throws exception

The last element is at index 2. Trying to access index 3 is out of bounds.

C Sharp (C#)

int[] numbers = { 10, 20, 30 };
int last = numbers[2]; // Last valid element
int invalid = numbers[3]; // Throws exception

Sample Program

This program prints all valid elements of the array. Then it tries to access an invalid index, which causes an exception. The exception is caught and its message is printed.

C Sharp (C#)

using System;

class Program
{
    static void Main()
    {
        int[] scores = { 85, 90, 78 };

        Console.WriteLine("Scores array elements:");
        for (int index = 0; index < scores.Length; index++)
        {
            Console.WriteLine($"Index {index}: {scores[index]}");
        }

        try
        {
            Console.WriteLine("Trying to access index 3 (out of bounds):");
            int invalidScore = scores[3];
        }
        catch (IndexOutOfRangeException e)
        {
            Console.WriteLine("Error: " + e.Message);
        }
    }
}

Important Notes

Array bounds checking happens automatically in C# for safety.

Time complexity for accessing an element is O(1), but checking adds a tiny overhead.

Common mistake: forgetting that arrays start at index 0, so the last valid index is length - 1.

Use bounds checking to avoid crashes, but if you need faster code and are sure about indexes, unsafe code can skip checks (advanced topic).

Summary

Array bounds checking prevents accessing invalid indexes.

Accessing outside the array throws an IndexOutOfRangeException.

Always use indexes between 0 and array length - 1.

Practice

1. What happens if you try to access an array element with an index less than 0 in C#?

easy

A. It throws an IndexOutOfRangeException.

B. It returns the first element of the array.

C. It returns null.

D. It automatically adjusts the index to 0.

Solution

1. Step 1: Understand array index rules in C#

   Array indexes must be between 0 and array length - 1.

2. Step 2: Behavior on invalid index

   Accessing an index less than 0 is outside valid range and causes an exception.

3. Final Answer:

   It throws an IndexOutOfRangeException. -> Option A

4. Quick Check:

   Invalid index access = IndexOutOfRangeException [OK]

Hint: Negative indexes always cause IndexOutOfRangeException [OK]

Common Mistakes:

• Thinking negative index returns first element
• Assuming negative index returns null
• Believing index auto-corrects to 0

2. Which of the following is the correct way to declare and access the third element of an integer array named numbers in C#?

easy

A. int value = numbers[3];

B. int value = numbers[0];

C. int value = numbers[1];

D. int value = numbers[2];

Solution

1. Step 1: Recall zero-based indexing in C# arrays

   Array indexes start at 0, so the first element is numbers[0].

2. Step 2: Identify the third element index

   The third element is at index 2 (0,1,2).

3. Final Answer:

   int value = numbers[2]; -> Option D

4. Quick Check:

   Third element index = 2 [OK]

Hint: Remember array indexing starts at zero [OK]

Common Mistakes:

• Using index 3 for third element
• Confusing element position with index
• Accessing index 1 or 0 for third element

3. What will be the output of the following C# code?

int[] arr = {10, 20, 30};
Console.WriteLine(arr[3]);

medium

A. 0

B. IndexOutOfRangeException

C. 30

D. 20

Solution

1. Step 1: Check array length and valid indexes

   Array has 3 elements with indexes 0, 1, 2.

2. Step 2: Accessing index 3

   Index 3 is outside the array bounds, causing an exception.

3. Final Answer:

   IndexOutOfRangeException -> Option B

4. Quick Check:

   Accessing arr[3] = IndexOutOfRangeException [OK]

Hint: Indexes must be less than array length [OK]

Common Mistakes:

• Expecting last element value instead of error
• Assuming default zero value returned
• Confusing index 3 with valid index

4. Consider this code snippet:

int[] data = new int[5];
data[5] = 100;

What is the issue and how to fix it?

medium

A. Syntax error due to array declaration.

B. No issue, code runs fine.

C. IndexOutOfRangeException because index 5 is invalid; fix by using index 4.

D. NullReferenceException because array is not initialized.

Solution

1. Step 1: Analyze array size and valid indexes

   Array size is 5, valid indexes are 0 to 4.

2. Step 2: Identify invalid index usage

   Accessing data[5] is outside bounds, causing IndexOutOfRangeException.

3. Step 3: Correct the index

   Use data[4] to access the last element safely.

4. Final Answer:

   IndexOutOfRangeException because index 5 is invalid; fix by using index 4. -> Option C

5. Quick Check:

   Index 5 invalid, max index 4 [OK]

Hint: Last index is length minus one [OK]

Common Mistakes:

• Assuming index 5 is valid for length 5
• Confusing syntax error with runtime error
• Thinking array is uninitialized

5. You have an array int[] scores = {5, 10, 15};. You want to safely print the element at index i without causing an exception. Which code snippet correctly checks bounds before accessing?

hard

A. if (i >= 0 && i < scores.Length) Console.WriteLine(scores[i]); else Console.WriteLine("Invalid index");

B. if (i > 0 && i <= scores.Length) Console.WriteLine(scores[i]); else Console.WriteLine("Invalid index");

C. if (i >= 1 && i < scores.Length) Console.WriteLine(scores[i]); else Console.WriteLine("Invalid index");

D. if (i > 0 && i < scores.Length - 1) Console.WriteLine(scores[i]); else Console.WriteLine("Invalid index");

Solution

1. Step 1: Understand valid index range for array

   Valid indexes are from 0 up to Length - 1.

2. Step 2: Check each condition

   if (i >= 0 && i < scores.Length) Console.WriteLine(scores[i]); else Console.WriteLine("Invalid index"); correctly checks i >= 0 and i < Length, ensuring safe access.

3. Step 3: Identify incorrect conditions

   Other options exclude index 0 or allow invalid upper bounds.

4. Final Answer:

   if (i >= 0 && i < scores.Length) Console.WriteLine(scores[i]); else Console.WriteLine("Invalid index"); -> Option A

5. Quick Check:

   Bounds check: 0 ≤ i < Length [OK]

Hint: Check index >= 0 and < array length [OK]

Common Mistakes:

• Using > 0 instead of >= 0
• Allowing index equal to length
• Ignoring zero index as valid