Fix: Index was outside the bounds of the array C# error

The ‘Index was outside the bounds of the array’ error, also known as IndexOutOfRangeException, is a common C# runtime error that occurs when trying to access an array element using an index that is outside the valid range. This error happens when you attempt to access an array element at a position that doesn’t exist, such as accessing index 5 in an array that only has 5 elements (indices 0-4). This error can cause application crashes and is often difficult to debug, especially in complex applications with dynamic array operations.

This comprehensive guide explains what causes this error, why it happens, and provides multiple solutions to fix it in your C# projects with clean code examples and directory structure.

---

What is the Index Was Outside the Bounds of the Array Error?

The “Index was outside the bounds of the array” error occurs when:

• Accessing an array element with an index that is negative
• Accessing an array element with an index equal to or greater than the array length
• Using an index that exceeds the collection size
• Iterating beyond the array boundaries
• Using calculated indices without proper validation
• Accessing jagged array elements incorrectly

Common Error Messages:

• System.IndexOutOfRangeException: Index was outside the bounds of the array
• IndexOutOfRangeException: Index was outside the bounds of the array
• System.IndexOutOfRangeException: Index was outside the bounds of the array. at ...

---

Understanding the Problem

The IndexOutOfRangeException is a runtime error that occurs when your code attempts to access an element in an array, list, or other collection using an invalid index. In C#, arrays are zero-indexed, meaning the first element is at index 0, and the last element is at index Length - 1. Attempting to access an index outside this range results in this exception.

Typical C# Project Structure:

MyCSharpApp/
├── MyCSharpApp.sln
├── src/
│   ├── MyCSharpApp/
│   │   ├── Program.cs
│   │   ├── Controllers/
│   │   │   ├── HomeController.cs
│   │   │   └── DataController.cs
│   │   ├── Models/
│   │   │   ├── DataModel.cs
│   │   │   └── ArrayProcessor.cs
│   │   ├── Services/
│   │   │   ├── ArrayService.cs
│   │   │   └── DataService.cs
│   │   ├── Utilities/
│   │   │   └── ArrayHelper.cs
│   │   ├── MyCSharpApp.csproj
│   │   └── appsettings.json
│   └── MyCSharpApp.Tests/
│       ├── UnitTests.cs
│       └── MyCSharpApp.Tests.csproj
├── packages/
└── bin/

---

Solution 1: Proper Bounds Checking

The most fundamental solution is to check array bounds before accessing elements.

❌ Without Bounds Checking:

// Services/ArrayService.cs - ❌ No bounds checking
public class ArrayService
{
    public int GetElement(int[] array, int index)
    {
        // ❌ Error: IndexOutOfRangeException if index is out of bounds
        return array[index];
    }
}

✅ With Proper Bounds Checking:

Services/ArrayService.cs:

using System;
using System.Collections.Generic;
using System.Linq;

namespace MyCSharpApp.Services
{
    public interface IArrayService
    {
        int GetElement(int[] array, int index);
        bool TryGetElement(int[] array, int index, out int element);
        int GetElementOrDefault(int[] array, int index, int defaultValue = 0);
        List<int> GetRange(int[] array, int startIndex, int count);
        int[] SafeCopy(int[] source, int sourceIndex, int length);
    }

    public class ArrayService : IArrayService
    {
        public int GetElement(int[] array, int index)
        {
            // ✅ Check for null array
            if (array == null)
            {
                throw new ArgumentNullException(nameof(array));
            }
            
            // ✅ Check if index is within bounds
            if (index < 0 || index >= array.Length)
            {
                throw new IndexOutOfRangeException($"Index {index} is outside the bounds of the array with length {array.Length}");
            }
            
            return array[index];
        }

        public bool TryGetElement(int[] array, int index, out int element)
        {
            element = 0;
            
            // ✅ Check for null array
            if (array == null)
            {
                return false;
            }
            
            // ✅ Check if index is within bounds
            if (index < 0 || index >= array.Length)
            {
                return false;
            }
            
            element = array[index];
            return true;
        }

        public int GetElementOrDefault(int[] array, int index, int defaultValue = 0)
        {
            // ✅ Safe bounds checking with default return
            if (array == null || index < 0 || index >= array.Length)
            {
                return defaultValue;
            }
            
            return array[index];
        }

        public List<int> GetRange(int[] array, int startIndex, int count)
        {
            // ✅ Validate parameters
            if (array == null)
            {
                throw new ArgumentNullException(nameof(array));
            }
            
            if (startIndex < 0 || startIndex >= array.Length)
            {
                throw new ArgumentOutOfRangeException(nameof(startIndex), "Start index is out of range");
            }
            
            if (count < 0)
            {
                throw new ArgumentOutOfRangeException(nameof(count), "Count cannot be negative");
            }
            
            if (startIndex + count > array.Length)
            {
                throw new ArgumentException("Range exceeds array bounds");
            }
            
            // ✅ Create result list with proper bounds checking
            var result = new List<int>();
            for (int i = startIndex; i < startIndex + count; i++)
            {
                result.Add(array[i]);
            }
            
            return result;
        }

        public int[] SafeCopy(int[] source, int sourceIndex, int length)
        {
            // ✅ Validate parameters
            if (source == null)
            {
                throw new ArgumentNullException(nameof(source));
            }
            
            if (sourceIndex < 0 || sourceIndex >= source.Length)
            {
                throw new ArgumentOutOfRangeException(nameof(sourceIndex), "Source index is out of range");
            }
            
            if (length < 0)
            {
                throw new ArgumentOutOfRangeException(nameof(length), "Length cannot be negative");
            }
            
            if (sourceIndex + length > source.Length)
            {
                throw new ArgumentException("Length exceeds array bounds");
            }
            
            // ✅ Create destination array and copy elements safely
            var destination = new int[length];
            Array.Copy(source, sourceIndex, destination, 0, length);
            
            return destination;
        }

        // ✅ Method with multiple bounds checks
        public int[] ProcessArraySegment(int[] array, int start, int end)
        {
            if (array == null)
            {
                throw new ArgumentNullException(nameof(array));
            }
            
            if (start < 0 || start >= array.Length)
            {
                throw new ArgumentOutOfRangeException(nameof(start), "Start index is out of range");
            }
            
            if (end < 0 || end >= array.Length)
            {
                throw new ArgumentOutOfRangeException(nameof(end), "End index is out of range");
            }
            
            if (start > end)
            {
                throw new ArgumentException("Start index cannot be greater than end index");
            }
            
            // ✅ Process the segment safely
            var result = new int[end - start + 1];
            for (int i = 0; i < result.Length; i++)
            {
                result[i] = array[start + i];
            }
            
            return result;
        }

        // ✅ Method with safe iteration
        public int SumArrayRange(int[] array, int startIndex, int endIndex)
        {
            if (array == null)
            {
                return 0;
            }
            
            // ✅ Adjust bounds to be within array limits
            startIndex = Math.Max(0, startIndex);
            endIndex = Math.Min(array.Length - 1, endIndex);
            
            if (startIndex > endIndex)
            {
                return 0;
            }
            
            // ✅ Safe summation with bounds checking
            int sum = 0;
            for (int i = startIndex; i <= endIndex; i++)
            {
                sum += array[i];
            }
            
            return sum;
        }
    }
}

---

Solution 2: Use Safe Array Access Methods

Create helper methods that provide safe array access with built-in bounds checking.

Utilities/ArrayHelper.cs:

using System;
using System.Collections.Generic;

namespace MyCSharpApp.Utilities
{
    public static class ArrayHelper
    {
        // ✅ Safe indexer for arrays
        public static T SafeGet<T>(T[] array, int index, T defaultValue = default(T))
        {
            if (array == null || index < 0 || index >= array.Length)
            {
                return defaultValue;
            }
            
            return array[index];
        }

        // ✅ Safe indexer for lists
        public static T SafeGet<T>(List<T> list, int index, T defaultValue = default(T))
        {
            if (list == null || index < 0 || index >= list.Count)
            {
                return defaultValue;
            }
            
            return list[index];
        }

        // ✅ Safe indexer for strings
        public static char SafeGet(this string str, int index, char defaultValue = '\0')
        {
            if (string.IsNullOrEmpty(str) || index < 0 || index >= str.Length)
            {
                return defaultValue;
            }
            
            return str[index];
        }

        // ✅ Safe set method for arrays
        public static bool SafeSet<T>(T[] array, int index, T value)
        {
            if (array == null || index < 0 || index >= array.Length)
            {
                return false;
            }
            
            array[index] = value;
            return true;
        }

        // ✅ Safe set method for lists
        public static bool SafeSet<T>(List<T> list, int index, T value)
        {
            if (list == null || index < 0 || index >= list.Count)
            {
                return false;
            }
            
            list[index] = value;
            return true;
        }

        // ✅ Safe range check
        public static bool IsInRange<T>(T[] array, int index)
        {
            return array != null && index >= 0 && index < array.Length;
        }

        // ✅ Safe range check for lists
        public static bool IsInRange<T>(List<T> list, int index)
        {
            return list != null && index >= 0 && index < list.Count;
        }

        // ✅ Safe array expansion
        public static T[] SafeExpand<T>(T[] array, int newSize, T defaultValue = default(T))
        {
            if (newSize <= 0)
            {
                return new T[0];
            }
            
            var newArray = new T[newSize];
            
            if (array != null)
            {
                var copySize = Math.Min(array.Length, newSize);
                Array.Copy(array, newArray, copySize);
                
                // ✅ Fill remaining positions with default value
                for (int i = copySize; i < newSize; i++)
                {
                    newArray[i] = defaultValue;
                }
            }
            else
            {
                // ✅ Fill entire array with default value
                for (int i = 0; i < newSize; i++)
                {
                    newArray[i] = defaultValue;
                }
            }
            
            return newArray;
        }

        // ✅ Safe array concatenation
        public static T[] SafeConcatenate<T>(params T[][] arrays)
        {
            if (arrays == null)
            {
                return new T[0];
            }
            
            int totalLength = 0;
            foreach (var arr in arrays)
            {
                if (arr != null)
                {
                    totalLength += arr.Length;
                }
            }
            
            var result = new T[totalLength];
            int currentIndex = 0;
            
            foreach (var arr in arrays)
            {
                if (arr != null)
                {
                    Array.Copy(arr, 0, result, currentIndex, arr.Length);
                    currentIndex += arr.Length;
                }
            }
            
            return result;
        }

        // ✅ Safe array slicing
        public static T[] SafeSlice<T>(T[] array, int startIndex, int length)
        {
            if (array == null || startIndex < 0 || length <= 0)
            {
                return new T[0];
            }
            
            // ✅ Adjust parameters to fit within array bounds
            startIndex = Math.Min(startIndex, array.Length);
            length = Math.Min(length, array.Length - startIndex);
            
            if (length <= 0)
            {
                return new T[0];
            }
            
            var result = new T[length];
            Array.Copy(array, startIndex, result, 0, length);
            
            return result;
        }

        // ✅ Safe array reversal
        public static T[] SafeReverse<T>(T[] array)
        {
            if (array == null || array.Length <= 1)
            {
                return array?.Length > 0 ? (T[])array.Clone() : new T[0];
            }
            
            var reversed = new T[array.Length];
            for (int i = 0; i < array.Length; i++)
            {
                reversed[i] = array[array.Length - 1 - i];
            }
            
            return reversed;
        }
    }
}

---

Solution 3: Proper Array Initialization and Management

Ensure arrays are properly initialized and managed to prevent bounds errors.

Models/ArrayProcessor.cs:

using System;
using System.Collections.Generic;
using System.Linq;

namespace MyCSharpApp.Models
{
    public class ArrayProcessor
    {
        private int[] _data;
        private int _size;

        public ArrayProcessor(int initialCapacity = 10)
        {
            if (initialCapacity <= 0)
            {
                throw new ArgumentException("Initial capacity must be positive", nameof(initialCapacity));
            }
            
            _data = new int[initialCapacity];
            _size = 0;
        }

        public int Length => _size;
        public int Capacity => _data.Length;

        // ✅ Add element with capacity management
        public void Add(int value)
        {
            if (_size >= _data.Length)
            {
                // ✅ Expand array when needed
                ExpandCapacity();
            }
            
            _data[_size] = value;
            _size++;
        }

        // ✅ Insert element at specific index
        public void Insert(int index, int value)
        {
            if (index < 0 || index > _size)
            {
                throw new IndexOutOfRangeException($"Index {index} is out of range for array of size {_size}");
            }
            
            if (_size >= _data.Length)
            {
                ExpandCapacity();
            }
            
            // ✅ Shift elements to make room
            for (int i = _size; i > index; i--)
            {
                _data[i] = _data[i - 1];
            }
            
            _data[index] = value;
            _size++;
        }

        // ✅ Remove element at specific index
        public bool RemoveAt(int index)
        {
            if (index < 0 || index >= _size)
            {
                return false;
            }
            
            // ✅ Shift elements to fill the gap
            for (int i = index; i < _size - 1; i++)
            {
                _data[i] = _data[i + 1];
            }
            
            _size--;
            return true;
        }

        // ✅ Get element with bounds checking
        public int this[int index]
        {
            get
            {
                if (index < 0 || index >= _size)
                {
                    throw new IndexOutOfRangeException($"Index {index} is out of range for array of size {_size}");
                }
                
                return _data[index];
            }
            set
            {
                if (index < 0 || index >= _size)
                {
                    throw new IndexOutOfRangeException($"Index {index} is out of range for array of size {_size}");
                }
                
                _data[index] = value;
            }
        }

        // ✅ Safe get method
        public bool TryGet(int index, out int value)
        {
            value = 0;
            
            if (index < 0 || index >= _size)
            {
                return false;
            }
            
            value = _data[index];
            return true;
        }

        // ✅ Safe set method
        public bool TrySet(int index, int value)
        {
            if (index < 0 || index >= _size)
            {
                return false;
            }
            
            _data[index] = value;
            return true;
        }

        // ✅ Expand capacity when needed
        private void ExpandCapacity()
        {
            var newCapacity = _data.Length * 2;
            var newData = new int[newCapacity];
            
            Array.Copy(_data, newData, _size);
            _data = newData;
        }

        // ✅ Trim excess capacity
        public void TrimExcess()
        {
            if (_data.Length > _size)
            {
                var trimmedData = new int[_size];
                Array.Copy(_data, trimmedData, _size);
                _data = trimmedData;
            }
        }

        // ✅ Convert to array
        public int[] ToArray()
        {
            var result = new int[_size];
            Array.Copy(_data, result, _size);
            return result;
        }

        // ✅ Clear the array
        public void Clear()
        {
            _size = 0;
        }

        // ✅ Find element
        public int IndexOf(int value)
        {
            for (int i = 0; i < _size; i++)
            {
                if (_data[i] == value)
                {
                    return i;
                }
            }
            
            return -1;
        }

        // ✅ Contains element
        public bool Contains(int value)
        {
            return IndexOf(value) >= 0;
        }

        // ✅ Copy to another array
        public void CopyTo(int[] destination, int destinationIndex)
        {
            if (destination == null)
            {
                throw new ArgumentNullException(nameof(destination));
            }
            
            if (destinationIndex < 0 || destinationIndex + _size > destination.Length)
            {
                throw new ArgumentException("Destination array is not large enough");
            }
            
            Array.Copy(_data, 0, destination, destinationIndex, _size);
        }

        // ✅ Get range of elements
        public int[] GetRange(int startIndex, int count)
        {
            if (startIndex < 0 || startIndex >= _size)
            {
                throw new IndexOutOfRangeException("Start index is out of range");
            }
            
            if (count < 0 || startIndex + count > _size)
            {
                throw new ArgumentException("Range exceeds array bounds");
            }
            
            var result = new int[count];
            Array.Copy(_data, startIndex, result, 0, count);
            return result;
        }
    }
}

---

Solution 4: Use LINQ and Collection Methods Safely

Leverage LINQ and collection methods that handle bounds checking internally.

Services/DataService.cs:

using System;
using System.Collections.Generic;
using System.Linq;

namespace MyCSharpApp.Services
{
    public interface IDataService
    {
        List<int> GetDataSubset(int[] data, int startIndex, int count);
        int[] GetFilteredData(int[] data, Func<int, bool> predicate);
        List<int> GetSortedData(int[] data);
        int[] GetReversedData(int[] data);
        bool ContainsElement(int[] data, int element);
    }

    public class DataService : IDataService
    {
        public List<int> GetDataSubset(int[] data, int startIndex, int count)
        {
            if (data == null)
            {
                return new List<int>();
            }
            
            // ✅ Use LINQ with safe bounds checking
            if (startIndex < 0 || startIndex >= data.Length)
            {
                return new List<int>();
            }
            
            if (count <= 0)
            {
                return new List<int>();
            }
            
            // ✅ Use LINQ Skip and Take for safe subset extraction
            return data.Skip(startIndex).Take(count).ToList();
        }

        public int[] GetFilteredData(int[] data, Func<int, bool> predicate)
        {
            if (data == null || predicate == null)
            {
                return new int[0];
            }
            
            // ✅ Use LINQ Where for safe filtering
            return data.Where(predicate).ToArray();
        }

        public List<int> GetSortedData(int[] data)
        {
            if (data == null)
            {
                return new List<int>();
            }
            
            // ✅ Use LINQ OrderBy for safe sorting
            return data.OrderBy(x => x).ToList();
        }

        public int[] GetReversedData(int[] data)
        {
            if (data == null)
            {
                return new int[0];
            }
            
            // ✅ Use LINQ Reverse for safe reversal
            return data.Reverse().ToArray();
        }

        public bool ContainsElement(int[] data, int element)
        {
            if (data == null)
            {
                return false;
            }
            
            // ✅ Use LINQ Contains for safe element checking
            return data.Contains(element);
        }

        // ✅ Safe aggregation methods
        public int GetSum(int[] data, int startIndex, int count)
        {
            if (data == null)
            {
                return 0;
            }
            
            // ✅ Use LINQ with safe bounds
            var safeStart = Math.Max(0, startIndex);
            var safeCount = Math.Min(count, data.Length - safeStart);
            
            if (safeCount <= 0)
            {
                return 0;
            }
            
            return data.Skip(safeStart).Take(safeCount).Sum();
        }

        // ✅ Safe average calculation
        public double GetAverage(int[] data, int startIndex, int count)
        {
            if (data == null)
            {
                return 0;
            }
            
            var safeStart = Math.Max(0, startIndex);
            var safeCount = Math.Min(count, data.Length - safeStart);
            
            if (safeCount <= 0)
            {
                return 0;
            }
            
            var subset = data.Skip(safeStart).Take(safeCount).ToArray();
            return subset.Length > 0 ? subset.Average() : 0;
        }

        // ✅ Safe min/max operations
        public (int min, int max) GetMinMax(int[] data)
        {
            if (data == null || data.Length == 0)
            {
                return (0, 0);
            }
            
            return (data.Min(), data.Max());
        }

        // ✅ Safe grouping operations
        public Dictionary<int, List<int>> GroupByModulo(int[] data, int modulo)
        {
            if (data == null || modulo <= 0)
            {
                return new Dictionary<int, List<int>>();
            }
            
            // ✅ Use LINQ GroupBy with safe operations
            return data.GroupBy(x => x % modulo)
                      .ToDictionary(g => g.Key, g => g.ToList());
        }

        // ✅ Safe distinct operations
        public int[] GetDistinctValues(int[] data)
        {
            if (data == null)
            {
                return new int[0];
            }
            
            // ✅ Use LINQ Distinct for safe deduplication
            return data.Distinct().ToArray();
        }

        // ✅ Safe join operations
        public int[] JoinArrays(int[] first, int[] second)
        {
            if (first == null && second == null)
            {
                return new int[0];
            }
            
            if (first == null)
            {
                return second.ToArray();
            }
            
            if (second == null)
            {
                return first.ToArray();
            }
            
            // ✅ Use LINQ Concat for safe joining
            return first.Concat(second).ToArray();
        }
    }
}

---

Solution 5: Handle Jagged Arrays Safely

Properly handle multidimensional and jagged arrays to prevent bounds errors.

Utilities/JaggedArrayHelper.cs:

using System;

namespace MyCSharpApp.Utilities
{
    public static class JaggedArrayHelper
    {
        // ✅ Safe access to jagged arrays
        public static T SafeGetJagged<T>(T[][] jaggedArray, int outerIndex, int innerIndex, T defaultValue = default(T))
        {
            if (jaggedArray == null || 
                outerIndex < 0 || 
                outerIndex >= jaggedArray.Length || 
                jaggedArray[outerIndex] == null || 
                innerIndex < 0 || 
                innerIndex >= jaggedArray[outerIndex].Length)
            {
                return defaultValue;
            }
            
            return jaggedArray[outerIndex][innerIndex];
        }

        // ✅ Safe set for jagged arrays
        public static bool SafeSetJagged<T>(T[][] jaggedArray, int outerIndex, int innerIndex, T value)
        {
            if (jaggedArray == null || 
                outerIndex < 0 || 
                outerIndex >= jaggedArray.Length || 
                jaggedArray[outerIndex] == null || 
                innerIndex < 0 || 
                innerIndex >= jaggedArray[outerIndex].Length)
            {
                return false;
            }
            
            jaggedArray[outerIndex][innerIndex] = value;
            return true;
        }

        // ✅ Safe access to 2D arrays
        public static T SafeGet2D<T>(T[,] array2D, int row, int col, T defaultValue = default(T))
        {
            if (array2D == null || 
                row < 0 || 
                row >= array2D.GetLength(0) || 
                col < 0 || 
                col >= array2D.GetLength(1))
            {
                return defaultValue;
            }
            
            return array2D[row, col];
        }

        // ✅ Safe set for 2D arrays
        public static bool SafeSet2D<T>(T[,] array2D, int row, int col, T value)
        {
            if (array2D == null || 
                row < 0 || 
                row >= array2D.GetLength(0) || 
                col < 0 || 
                col >= array2D.GetLength(1))
            {
                return false;
            }
            
            array2D[row, col] = value;
            return true;
        }

        // ✅ Get dimensions safely
        public static (int rows, int cols) GetDimensions<T>(T[,] array2D)
        {
            if (array2D == null)
            {
                return (0, 0);
            }
            
            return (array2D.GetLength(0), array2D.GetLength(1));
        }

        // ✅ Get jagged array dimensions
        public static (int outerLength, int[] innerLengths) GetJaggedDimensions<T>(T[][] jaggedArray)
        {
            if (jaggedArray == null)
            {
                return (0, new int[0]);
            }
            
            var innerLengths = new int[jaggedArray.Length];
            for (int i = 0; i < jaggedArray.Length; i++)
            {
                innerLengths[i] = jaggedArray[i]?.Length ?? 0;
            }
            
            return (jaggedArray.Length, innerLengths);
        }

        // ✅ Safe iteration over jagged array
        public static void ForEachJagged<T>(T[][] jaggedArray, Action<T, int, int> action)
        {
            if (jaggedArray == null || action == null)
            {
                return;
            }
            
            for (int i = 0; i < jaggedArray.Length; i++)
            {
                if (jaggedArray[i] != null)
                {
                    for (int j = 0; j < jaggedArray[i].Length; j++)
                    {
                        action(jaggedArray[i][j], i, j);
                    }
                }
            }
        }

        // ✅ Safe iteration over 2D array
        public static void ForEach2D<T>(T[,] array2D, Action<T, int, int> action)
        {
            if (array2D == null || action == null)
            {
                return;
            }
            
            int rows = array2D.GetLength(0);
            int cols = array2D.GetLength(1);
            
            for (int i = 0; i < rows; i++)
            {
                for (int j = 0; j < cols; j++)
                {
                    action(array2D[i, j], i, j);
                }
            }
        }

        // ✅ Safe transpose of 2D array
        public static T[,] Transpose<T>(T[,] original)
        {
            if (original == null)
            {
                return null;
            }
            
            int rows = original.GetLength(0);
            int cols = original.GetLength(1);
            
            var transposed = new T[cols, rows];
            
            for (int i = 0; i < rows; i++)
            {
                for (int j = 0; j < cols; j++)
                {
                    transposed[j, i] = original[i, j];
                }
            }
            
            return transposed;
        }

        // ✅ Safe initialization of jagged array
        public static T[][] InitializeJagged<T>(int outerSize, int[] innerSizes, T defaultValue = default(T))
        {
            if (outerSize <= 0 || innerSizes == null || innerSizes.Length != outerSize)
            {
                return new T[0][];
            }
            
            var jaggedArray = new T[outerSize][];
            
            for (int i = 0; i < outerSize; i++)
            {
                var innerSize = Math.Max(0, innerSizes[i]);
                jaggedArray[i] = new T[innerSize];
                
                // ✅ Initialize with default value
                for (int j = 0; j < innerSize; j++)
                {
                    jaggedArray[i][j] = defaultValue;
                }
            }
            
            return jaggedArray;
        }
    }
}

---

Working Code Examples

Complete C# Application with Safe Array Operations:

// Program.cs
using MyCSharpApp.Services;
using MyCSharpApp.Utilities;
using MyCSharpApp.Models;
using Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using System;

var builder = WebApplication.CreateBuilder(args);

// ✅ Add services to the container
builder.Services.AddControllers();
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

// ✅ Register custom services
builder.Services.AddScoped<IArrayService, ArrayService>();
builder.Services.AddScoped<IDataService, DataService>();

var app = builder.Build();

// ✅ Demonstrate safe array operations
try
{
    // ✅ Safe array access
    var array = new int[] { 1, 2, 3, 4, 5 };
    var element = ArrayHelper.SafeGet(array, 2); // ✅ Safe access
    Console.WriteLine($"Element at index 2: {element}");

    // ✅ Safe access with out-of-bounds index
    var safeElement = ArrayHelper.SafeGet(array, 10, -1); // ✅ Returns default value
    Console.WriteLine($"Element at index 10: {safeElement}");

    // ✅ Safe string access
    var text = "Hello World";
    var charAt = text.SafeGet(6); // ✅ Safe character access
    Console.WriteLine($"Character at index 6: {charAt}");

    // ✅ Array processor example
    var processor = new ArrayProcessor(5);
    processor.Add(10);
    processor.Add(20);
    processor.Add(30);
    
    Console.WriteLine($"Processor length: {processor.Length}");
    Console.WriteLine($"Element at index 1: {processor[1]}");

    // ✅ Safe jagged array operations
    var jagged = new int[][]
    {
        new int[] { 1, 2, 3 },
        new int[] { 4, 5 },
        new int[] { 6, 7, 8, 9 }
    };
    
    var jaggedValue = JaggedArrayHelper.SafeGetJagged(jagged, 1, 1); // ✅ Safe access
    Console.WriteLine($"Jagged array value: {jaggedValue}");

    // ✅ Safe 2D array operations
    var array2D = new int[,] { { 1, 2 }, { 3, 4 }, { 5, 6 } };
    var value2D = JaggedArrayHelper.SafeGet2D(array2D, 1, 0); // ✅ Safe access
    Console.WriteLine($"2D array value: {value2D}");
}
catch (Exception ex)
{
    Console.WriteLine($"Error: {ex.Message}");
}

// ✅ Configure the HTTP request pipeline
if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

app.UseHttpsRedirection();
app.UseAuthorization();
app.MapControllers();

app.Run();

Controller with Safe Array Operations:

// Controllers/DataController.cs
using Microsoft.AspNetCore.Mvc;
using MyCSharpApp.Services;
using MyCSharpApp.Utilities;
using MyCSharpApp.Models;
using System.Collections.Generic;

namespace MyCSharpApp.Controllers
{
    [ApiController]
    [Route("api/[controller]")]
    public class DataController : ControllerBase
    {
        private readonly IArrayService _arrayService;
        private readonly IDataService _dataService;

        public DataController(IArrayService arrayService, IDataService dataService)
        {
            _arrayService = arrayService;
            _dataService = dataService;
        }

        [HttpGet("element/{index}")]
        public IActionResult GetElement(int index, [FromQuery] int[] data)
        {
            if (data == null || data.Length == 0)
            {
                return BadRequest("Data array cannot be null or empty");
            }

            try
            {
                // ✅ Safe element access with bounds checking
                var element = _arrayService.GetElementOrDefault(data, index, -1);
                return Ok(new { Index = index, Value = element, ArrayLength = data.Length });
            }
            catch (IndexOutOfRangeException ex)
            {
                return BadRequest(new { Error = ex.Message });
            }
        }

        [HttpGet("range")]
        public IActionResult GetRange([FromQuery] int[] data, [FromQuery] int start, [FromQuery] int count)
        {
            if (data == null || data.Length == 0)
            {
                return BadRequest("Data array cannot be null or empty");
            }

            try
            {
                // ✅ Safe range extraction
                var range = _arrayService.GetRange(data, start, count);
                return Ok(range);
            }
            catch (ArgumentOutOfRangeException ex)
            {
                return BadRequest(new { Error = ex.Message });
            }
        }

        [HttpPost("process")]
        public IActionResult ProcessData([FromBody] ProcessDataRequest request)
        {
            if (request?.Data == null || request.Data.Length == 0)
            {
                return BadRequest("Data cannot be null or empty");
            }

            // ✅ Safe data processing
            var processed = _dataService.GetFilteredData(request.Data, x => x > request.Threshold);
            return Ok(new { OriginalCount = request.Data.Length, FilteredCount = processed.Length, ProcessedData = processed });
        }

        [HttpGet("subset")]
        public IActionResult GetSubset([FromQuery] int[] data, [FromQuery] int start, [FromQuery] int count)
        {
            if (data == null || data.Length == 0)
            {
                return BadRequest("Data array cannot be null or empty");
            }

            // ✅ Safe subset extraction using helper
            var subset = _dataService.GetDataSubset(data, start, count);
            return Ok(subset);
        }

        [HttpGet("safe-get")]
        public IActionResult SafeGet([FromQuery] int[] data, [FromQuery] int index)
        {
            if (data == null)
            {
                return BadRequest("Data array cannot be null");
            }

            // ✅ Using safe helper method
            var value = ArrayHelper.SafeGet(data, index, -999);
            return Ok(new { Index = index, Value = value, IsSafe = true });
        }
    }

    public class ProcessDataRequest
    {
        public int[] Data { get; set; } = new int[0];
        public int Threshold { get; set; } = 0;
    }
}

Unit Test Example:

// MyCSharpApp.Tests/UnitTests.cs
using Microsoft.VisualStudio.TestTools.UnitTesting;
using MyCSharpApp.Services;
using MyCSharpApp.Utilities;
using MyCSharpApp.Models;
using System;

namespace MyCSharpApp.Tests
{
    [TestClass]
    public class ArrayBoundsTests
    {
        [TestMethod]
        public void ArrayService_GetElement_WithinBounds_ReturnsValue()
        {
            // ✅ Arrange
            var service = new ArrayService();
            var array = new int[] { 1, 2, 3, 4, 5 };
            
            // ✅ Act
            var result = service.GetElement(array, 2);
            
            // ✅ Assert
            Assert.AreEqual(3, result);
        }

        [TestMethod]
        public void ArrayService_GetElement_OutOfBounds_ThrowsException()
        {
            // ✅ Arrange
            var service = new ArrayService();
            var array = new int[] { 1, 2, 3 };
            
            // ✅ Act & Assert
            Assert.ThrowsException<IndexOutOfRangeException>(() => 
                service.GetElement(array, 5));
        }

        [TestMethod]
        public void ArrayService_GetElementOrDefault_OutOfBounds_ReturnsDefault()
        {
            // ✅ Arrange
            var service = new ArrayService();
            var array = new int[] { 1, 2, 3 };
            
            // ✅ Act
            var result = service.GetElementOrDefault(array, 5, -1);
            
            // ✅ Assert
            Assert.AreEqual(-1, result);
        }

        [TestMethod]
        public void ArrayHelper_SafeGet_WithinBounds_ReturnsValue()
        {
            // ✅ Arrange
            var array = new int[] { 10, 20, 30 };
            
            // ✅ Act
            var result = ArrayHelper.SafeGet(array, 1);
            
            // ✅ Assert
            Assert.AreEqual(20, result);
        }

        [TestMethod]
        public void ArrayHelper_SafeGet_OutOfBounds_ReturnsDefault()
        {
            // ✅ Arrange
            var array = new int[] { 10, 20, 30 };
            
            // ✅ Act
            var result = ArrayHelper.SafeGet(array, 10, -1);
            
            // ✅ Assert
            Assert.AreEqual(-1, result);
        }

        [TestMethod]
        public void ArrayProcessor_Add_ExpandsCapacity()
        {
            // ✅ Arrange
            var processor = new ArrayProcessor(2);
            
            // ✅ Act
            processor.Add(1);
            processor.Add(2);
            processor.Add(3); // ✅ Should trigger capacity expansion
            
            // ✅ Assert
            Assert.AreEqual(3, processor.Length);
            Assert.IsTrue(processor.Capacity >= 3);
        }

        [TestMethod]
        public void JaggedArrayHelper_SafeGetJagged_WithinBounds_ReturnsValue()
        {
            // ✅ Arrange
            var jagged = new int[][]
            {
                new int[] { 1, 2, 3 },
                new int[] { 4, 5 }
            };
            
            // ✅ Act
            var result = JaggedArrayHelper.SafeGetJagged(jagged, 1, 0);
            
            // ✅ Assert
            Assert.AreEqual(4, result);
        }

        [TestMethod]
        public void JaggedArrayHelper_SafeGetJagged_OutOfBounds_ReturnsDefault()
        {
            // ✅ Arrange
            var jagged = new int[][]
            {
                new int[] { 1, 2, 3 },
                new int[] { 4, 5 }
            };
            
            // ✅ Act
            var result = JaggedArrayHelper.SafeGetJagged(jagged, 5, 0, -1);
            
            // ✅ Assert
            Assert.AreEqual(-1, result);
        }
    }
}

---

Best Practices for Array Safety

1. Always Check Array Bounds

// ✅ Check array bounds before access
if (index >= 0 && index < array.Length)
{
    var element = array[index];
}

2. Use Safe Access Methods

// ✅ Use helper methods for safe access
var element = ArrayHelper.SafeGet(array, index, defaultValue);

3. Validate Parameters

// ✅ Validate method parameters
public void ProcessArray(int[] array, int index)
{
    if (array == null)
        throw new ArgumentNullException(nameof(array));
    
    if (index < 0 || index >= array.Length)
        throw new IndexOutOfRangeException(nameof(index));
    
    // Process the element
}

4. Use LINQ for Safe Operations

// ✅ Use LINQ for safe array operations
var result = array.Skip(startIndex).Take(count).ToList();

5. Implement Try-Pattern Methods

// ✅ Implement TryGet pattern
public bool TryGetElement(int[] array, int index, out int element)
{
    element = 0;
    if (array != null && index >= 0 && index < array.Length)
    {
        element = array[index];
        return true;
    }
    return false;
}

6. Use Collections When Possible

// ✅ Consider using List<T> instead of arrays for dynamic sizes
var list = new List<int>();
list.Add(element); // ✅ Automatically handles resizing

---

Debugging Steps

Step 1: Identify the Problematic Line

# Look for the stack trace to identify where the exception occurs
# The stack trace will show the exact line number

Step 2: Check Array Length

// Verify the array length before access
Console.WriteLine($"Array length: {array.Length}");
Console.WriteLine($"Trying to access index: {index}");

Step 3: Add Bounds Checking

// Add defensive bounds checking around the problematic code
if (index >= 0 && index < array.Length)
{
    // Safe to access array[index]
}

Step 4: Use Debugging Tools

# Use Visual Studio debugger to inspect array values
# Set breakpoints and examine the array length and index values

Step 5: Review Loop Conditions

// Check loop conditions for off-by-one errors
for (int i = 0; i < array.Length; i++) // ✅ Correct condition
{
    // Safe access: array[i]
}

// vs
for (int i = 0; i <= array.Length; i++) // ❌ Off-by-one error
{
    // Would cause IndexOutOfRangeException on last iteration
}

---

Common Mistakes to Avoid

1. Off-by-One Errors

// ❌ Off-by-one error
for (int i = 0; i <= array.Length; i++) // ❌ Should be < not <=
{
    Console.WriteLine(array[i]); // ❌ Will throw on last iteration
}

2. Negative Indices

// ❌ Negative index
var element = array[-1]; // ❌ Always throws IndexOutOfRangeException

3. Unvalidated User Input

// ❌ Not validating user input
int userIndex = GetUserInput(); // Could be any value
var element = array[userIndex]; // ❌ Could be out of bounds

4. Assuming Array Sizes

// ❌ Assuming array has minimum size
var element = array[5]; // ❌ Will fail if array has fewer than 6 elements

5. Jagged Array Mismanagement

// ❌ Not checking inner array bounds
var jagged = new int[3][]; // Outer array has 3 elements
jagged[0] = new int[2]; // But inner array only has 2 elements
var element = jagged[0][5]; // ❌ IndexOutOfRangeException

---

Performance Considerations

1. Minimize Bounds Checking in Hot Paths

// ❌ Too much bounds checking in performance-critical code
public void ProcessArray(int[] array)
{
    for (int i = 0; i < array.Length; i++)
    {
        if (i >= 0 && i < array.Length) // ❌ Redundant check
        {
            // Process array[i]
        }
    }
}

2. Use Unsafe Code Carefully (Advanced)

// ✅ For performance-critical scenarios (requires unsafe context)
unsafe
{
    fixed (int* ptr = array)
    {
        // Direct pointer access (bypasses bounds checking)
        // Only use when you're certain about bounds
    }
}

3. Pre-validate When Possible

// ✅ Validate once before the loop
if (array.Length > 0)
{
    for (int i = 0; i < array.Length; i++)
    {
        // Safe to access array[i] without additional checks
    }
}

---

Security Considerations

1. Validate Input Parameters

// ✅ Always validate input parameters
public void ProcessArray(int[] array, int startIndex, int count)
{
    if (array == null)
        throw new ArgumentNullException(nameof(array));
    
    if (startIndex < 0 || startIndex >= array.Length)
        throw new ArgumentOutOfRangeException(nameof(startIndex));
    
    if (count < 0 || startIndex + count > array.Length)
        throw new ArgumentException("Invalid range");
    
    // Safe to proceed with processing
}

2. Handle Malicious Input

// ✅ Handle potentially malicious input
public int GetElementSafely(int[] array, int index)
{
    // Validate index is within reasonable bounds
    if (index < 0 || index >= (array?.Length ?? 0))
    {
        // Log suspicious access attempt
        LogSecurityEvent($"Attempted to access index {index} in array of length {(array?.Length ?? 0)}");
        return 0; // Return safe default
    }
    
    return array[index];
}

3. Sanitize Array Operations

// ✅ Sanitize array operations
public int[] GetSafeRange(int[] source, int start, int length)
{
    if (source == null || start < 0 || length <= 0)
        return new int[0];
    
    // Clamp values to prevent overflow
    start = Math.Min(start, source.Length - 1);
    length = Math.Min(length, source.Length - start);
    
    if (length <= 0)
        return new int[0];
    
    var result = new int[length];
    Array.Copy(source, start, result, 0, length);
    return result;
}

---

Testing Array Bounds

1. Unit Test Boundary Conditions

[TestMethod]
public void GetElement_WithBoundaryIndices_DoesNotThrow()
{
    var service = new ArrayService();
    var array = new int[] { 1, 2, 3 };
    
    // Test first element
    Assert.AreEqual(1, service.GetElement(array, 0));
    
    // Test last element
    Assert.AreEqual(3, service.GetElement(array, 2));
    
    // Test out of bounds
    Assert.ThrowsException<IndexOutOfRangeException>(() => 
        service.GetElement(array, 3));
}

2. Test Empty Arrays

[TestMethod]
public void GetElement_WithEmptyArray_ThrowsException()
{
    var service = new ArrayService();
    var emptyArray = new int[0];
    
    Assert.ThrowsException<IndexOutOfRangeException>(() => 
        service.GetElement(emptyArray, 0));
}

3. Test Null Arrays

[TestMethod]
public void GetElement_WithNullArray_ThrowsException()
{
    var service = new ArrayService();
    
    Assert.ThrowsException<ArgumentNullException>(() => 
        service.GetElement(null, 0));
}

---

Alternative Solutions

1. Use Collections Instead of Arrays

// ✅ Use List<T> for dynamic sizing
var list = new List<int>();
list.Add(item); // ✅ Automatically handles resizing
var element = list.ElementAtOrDefault(index); // ✅ Safe access

2. Use Span for Performance (C# 7.2+)

// ✅ Use Span<T> for safe, efficient array-like operations
Span<int> span = array.AsSpan();
if (index < span.Length)
{
    var element = span[index]; // ✅ Safe access with bounds checking
}

3. Immutable Arrays with Validation

// ✅ Create wrapper with built-in validation
public class SafeArray<T>
{
    private readonly T[] _array;
    
    public SafeArray(T[] array)
    {
        _array = array ?? throw new ArgumentNullException(nameof(array));
    }
    
    public T this[int index]
    {
        get
        {
            if (index < 0 || index >= _array.Length)
                throw new IndexOutOfRangeException();
            return _array[index];
        }
    }
}

---

Migration Checklist

• Add bounds checking to all array access operations
• Replace direct array access with safe helper methods
• Validate all method parameters that accept indices
• Update unit tests to include boundary condition tests
• Review all loops for off-by-one errors
• Implement Try-pattern methods where appropriate
• Test all functionality after bounds safety changes
• Consider using collections instead of arrays where dynamic sizing is needed

---

Conclusion

The ‘Index was outside the bounds of the array’ error is a common but preventable C# runtime issue that occurs when accessing array elements with invalid indices. By following the solutions provided in this guide—implementing proper bounds checking, using safe access methods, validating parameters, and following best practices—you can effectively prevent and resolve this error in your C# applications.

The key is to understand C#‘s array indexing rules (zero-based, length-1 maximum), implement defensive programming practices, use modern C# features like LINQ for safe operations, and maintain clean, well-organized code. With proper array safety measures, your C# applications will be more resilient and less prone to runtime exceptions.

Remember to test your changes thoroughly, follow C# best practices for array handling, implement proper error handling, and regularly review your code for potential bounds issues to ensure your applications maintain the best possible architecture and avoid common runtime errors like IndexOutOfRangeException.