IndexOutOfRangeException Class

Definition

public ref class IndexOutOfRangeException sealed : Exception

public ref class IndexOutOfRangeException sealed : SystemException

public sealed class IndexOutOfRangeException : Exception

public sealed class IndexOutOfRangeException : SystemException

[System.Serializable]
public sealed class IndexOutOfRangeException : SystemException

[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class IndexOutOfRangeException : SystemException

type IndexOutOfRangeException = class
    inherit Exception

type IndexOutOfRangeException = class
    inherit SystemException

[<System.Serializable>]
type IndexOutOfRangeException = class
    inherit SystemException

[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type IndexOutOfRangeException = class
    inherit SystemException

Public NotInheritable Class IndexOutOfRangeException
Inherits Exception

Public NotInheritable Class IndexOutOfRangeException
Inherits SystemException

Inheritance

Object

Exception

IndexOutOfRangeException

Inheritance

Object

Exception

SystemException

IndexOutOfRangeException

Attributes

SerializableAttribute ComVisibleAttribute

Remarks

An IndexOutOfRangeException exception is thrown when an invalid index is used to access a member of an array or a collection, or to read or write from a particular location in a buffer. This exception inherits from the Exception class but adds no unique members.

Typically, an IndexOutOfRangeException exception is thrown as a result of developer error. Instead of handling the exception, you should diagnose the cause of the error and correct your code. The most common causes of the error are:

• Forgetting that the upper bound of a collection or a zero-based array is one less than its number of members or elements, as the following example illustrates.

  using System;
  using System.Collections.Generic;
  
  public class Example
  {
     public static void Main()
     {
        List<Char> characters = new List<Char>();
        characters.InsertRange(0, new Char[] { 'a', 'b', 'c', 'd', 'e', 'f' } );
        for (int ctr = 0; ctr <= characters.Count; ctr++)
           Console.Write("'{0}'    ", characters[ctr]);
     }
  }
  // The example displays the following output:
  //    'a'    'b'    'c'    'd'    'e'    'f'
  //    Unhandled Exception:
  //    System.ArgumentOutOfRangeException:
  //    Index was out of range. Must be non-negative and less than the size of the collection.
  //    Parameter name: index
  //       at Example.Main()
  

  let characters = ResizeArray()
  characters.InsertRange(0, [| 'a'; 'b'; 'c'; 'd'; 'e'; 'f' |])
  
  for i = 0 to characters.Count do
      printf $"'{characters[i]}'    "
  // The example displays the following output:
  //    'a'    'b'    'c'    'd'    'e'    'f'
  //    Unhandled Exception:
  //    System.ArgumentOutOfRangeException:
  //    Index was out of range. Must be non-negative and less than the size of the collection.
  //    Parameter name: index
  //       at <StartupCode$fs>.main@()
  

  Imports System.Collections.Generic
  
  Module Example
     Public Sub Main()
        Dim characters As New List(Of Char)()
        characters.InsertRange(0, { "a"c, "b"c, "c"c, "d"c, "e"c, "f"c} )
        For ctr As Integer = 0 To characters.Count
           Console.Write("'{0}'    ", characters(ctr))
        Next
     End Sub
  End Module
  ' The example displays the following output:
  '    'a'    'b'    'c'    'd'    'e'    'f'
  '    Unhandled Exception: 
  '    System.ArgumentOutOfRangeException: 
  '    Index was out of range. Must be non-negative and less than the size of the collection.
  '    Parameter name: index
  '       at System.Collections.Generic.List`1.get_Item(Int32 index)
  '       at Example.Main()
  

  To correct the error, you can use code like the following.

  using System;
  using System.Collections.Generic;
  
  public class Example
  {
     public static void Main()
     {
        List<Char> characters = new List<Char>();
        characters.InsertRange(0, new Char[] { 'a', 'b', 'c', 'd', 'e', 'f' } );
        for (int ctr = 0; ctr < characters.Count; ctr++)
           Console.Write("'{0}'    ", characters[ctr]);
     }
  }
  // The example displays the following output:
  //        'a'    'b'    'c'    'd'    'e'    'f'
  

  let characters = ResizeArray()
  characters.InsertRange(0, [| 'a'; 'b'; 'c'; 'd'; 'e'; 'f' |])
  
  for i = 0 to characters.Count - 1 do
      printf $"'{characters[i]}'    "
  // The example displays the following output:
  //        'a'    'b'    'c'    'd'    'e'    'f'
  

  Imports System.Collections.Generic
  
  Module Example
     Public Sub Main()
        Dim characters As New List(Of Char)()
        characters.InsertRange(0, { "a"c, "b"c, "c"c, "d"c, "e"c, "f"c} )
        For ctr As Integer = 0 To characters.Count - 1
           Console.Write("'{0}'    ", characters(ctr))
        Next
     End Sub
  End Module
  ' The example displays the following output:
  '       'a'    'b'    'c'    'd'    'e'    'f'
  

  Alternately, instead of iterating all the elements in the array by their index, you can use the foreach statement (in C#), the for...in statement (in F#), or the For Each statement (in Visual Basic).

• Attempting to assign an array element to another array that has not been adequately dimensioned and that has fewer elements than the original array. The following example attempts to assign the last element in the value1 array to the same element in the value2 array. However, the value2 array has been incorrectly dimensioned to have six instead of seven elements. As a result, the assignment throws an IndexOutOfRangeException exception.

  public class Example
  {
     public static void Main()
     {
        int[] values1 = { 3, 6, 9, 12, 15, 18, 21 };
        int[] values2 = new int[6];
  
        // Assign last element of the array to the new array.
        values2[values1.Length - 1] = values1[values1.Length - 1];
     }
  }
  // The example displays the following output:
  //       Unhandled Exception:
  //       System.IndexOutOfRangeException:
  //       Index was outside the bounds of the array.
  //       at Example.Main()
  

  let values1 = [| 3; 6; 9; 12; 15; 18; 21 |]
  let values2 = Array.zeroCreate<int> 6
  
  // Assign last element of the array to the new array.
  values2[values1.Length - 1] <- values1[values1.Length - 1];
  // The example displays the following output:
  //       Unhandled Exception:
  //       System.IndexOutOfRangeException:
  //       Index was outside the bounds of the array.
  //       at <StartupCode$fs>.main@()
  

  Module Example
     Public Sub Main()
        Dim values1() As Integer = { 3, 6, 9, 12, 15, 18, 21 }
        Dim values2(5) As Integer
        
        ' Assign last element of the array to the new array.
        values2(values1.Length - 1) = values1(values1.Length - 1)
     End Sub
  End Module
  ' The example displays the following output:
  '       Unhandled Exception: 
  '       System.IndexOutOfRangeException: 
  '       Index was outside the bounds of the array.
  '       at Example.Main()
  

• Using a value returned by a search method to iterate a portion of an array or collection starting at a particular index position. If you forget to check whether the search operation found a match, the runtime throws an IndexOutOfRangeException exception, as shown in this example.

  using System;
  using System.Collections.Generic;
  
  public class Example
  {
     static List<int> numbers = new List<int>();
  
     public static void Main()
     {
        int startValue;
        string[] args = Environment.GetCommandLineArgs();
        if (args.Length < 2)
           startValue = 2;
        else
           if (!Int32.TryParse(args[1], out startValue))
              startValue = 2;
  
        ShowValues(startValue);
     }
  
     private static void ShowValues(int startValue)
     {
        // Create a collection with numeric values.
        if (numbers.Count == 0)
           numbers.AddRange( new int[] { 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22} );
  
        // Get the index of a startValue.
        Console.WriteLine("Displaying values greater than or equal to {0}:",
                          startValue);
        int startIndex = numbers.IndexOf(startValue);
        // Display all numbers from startIndex on.
        for (int ctr = startIndex; ctr < numbers.Count; ctr++)
           Console.Write("    {0}", numbers[ctr]);
     }
  }
  // The example displays the following output if the user supplies
  // 7 as a command-line parameter:
  //    Displaying values greater than or equal to 7:
  //
  //    Unhandled Exception: System.ArgumentOutOfRangeException:
  //    Index was out of range. Must be non-negative and less than the size of the collection.
  //    Parameter name: index
  //       at System.Collections.Generic.List`1.get_Item(Int32 index)
  //       at Example.ShowValues(Int32 startValue)
  //       at Example.Main()
  

  open System
  
  let numbers = ResizeArray()
  
  let showValues startValue =
      // Create a collection with numeric values.
      if numbers.Count = 0 then
          numbers.AddRange [| 2..2..22 |]
  
      // Get the index of a startValue.
      printfn $"Displaying values greater than or equal to {startValue}:"
      let startIndex = numbers.IndexOf startValue
      
      // Display all numbers from startIndex on.
      for i = startIndex to numbers.Count - 1 do
          printf $"    {numbers[i]}"
  
  let startValue =
      let args = Environment.GetCommandLineArgs()
      if args.Length < 2 then
          2
      else
          match Int32.TryParse args[1] with
          | true, v -> v
          | _ -> 2
  
  showValues startValue
  
  // The example displays the following output if the user supplies
  // 7 as a command-line parameter:
  //    Displaying values greater than or equal to 7:
  //
  //    Unhandled Exception: System.ArgumentOutOfRangeException:
  //    Index was out of range. Must be non-negative and less than the size of the collection.
  //    Parameter name: index
  //       at System.Collections.Generic.List`1.get_Item(Int32 index)
  //       at Example.ShowValues(Int32 startValue)
  //       at <StartupCode$fs>.main@()
  

  Imports System.Collections.Generic
  
  Module Example
     Dim numbers As New List(Of Integer)
  
     Public Sub Main()
        Dim startValue As Integer 
        Dim args() As String = Environment.GetCommandLineArgs()
        If args.Length < 2 Then
           startValue = 2
        Else
           If Not Int32.TryParse(args(1), startValue) Then
              startValue = 2
           End If   
        End If
        ShowValues(startValue)
     End Sub
     
     Private Sub ShowValues(startValue As Integer)   
        ' Create a collection with numeric values.
        If numbers.Count = 0 Then 
           numbers.AddRange( { 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22} )
        End If   
        ' Get the index of a particular number, in this case 7.
        Console.WriteLine("Displaying values greater than or equal to {0}:",
                          startValue)
        Dim startIndex As Integer = numbers.IndexOf(startValue)
        ' Display all numbers from startIndex on.
        For ctr As Integer = startIndex To numbers.Count - 1
           Console.Write("    {0}", numbers(ctr))
        Next
     End Sub
  End Module
  ' The example displays the following output if the user supplies
  ' 7 as a command-line parameter:
  '    Displaying values greater than or equal to 7:
  '    
  '    Unhandled Exception: System.ArgumentOutOfRangeException: 
  '    Index was out of range. Must be non-negative and less than the size of the collection.
  '    Parameter name: index
  '       at System.Collections.Generic.List`1.get_Item(Int32 index)
  '       at Example.ShowValues(Int32 startValue)
  '       at Example.Main()
  

  In this case, the List<T>.IndexOf method returns -1, which is an invalid index value, when it fails to find a match. To correct this error, check the search method's return value before iterating the array, as shown in this example.

  using System;
  using System.Collections.Generic;
  
  public class Example
  {
     static List<int> numbers = new List<int>();
  
     public static void Main()
     {
        int startValue;
        string[] args = Environment.GetCommandLineArgs();
        if (args.Length < 2)
           startValue = 2;
        else
           if (!Int32.TryParse(args[1], out startValue))
              startValue = 2;
  
        ShowValues(startValue);
     }
  
     private static void ShowValues(int startValue)
     {
        // Create a collection with numeric values.
        if (numbers.Count == 0)
           numbers.AddRange( new int[] { 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22} );
  
        // Get the index of startValue.
        int startIndex = numbers.IndexOf(startValue);
        if (startIndex < 0) {
           Console.WriteLine("Unable to find {0} in the collection.", startValue);
        }
        else {
           // Display all numbers from startIndex on.
           Console.WriteLine("Displaying values greater than or equal to {0}:",
                          startValue);
           for (int ctr = startIndex; ctr < numbers.Count; ctr++)
              Console.Write("    {0}", numbers[ctr]);
        }
     }
  }
  // The example displays the following output if the user supplies
  // 7 as a command-line parameter:
  //      Unable to find 7 in the collection.
  

  open System
  open System.Collections.Generic
  
  let numbers = new List<int>()
  
  let showValues startValue =
      // Create a collection with numeric values.
      if numbers.Count = 0 then
          numbers.AddRange [| 2..2..22 |]
  
      // Get the index of startValue.
      let startIndex = numbers.IndexOf startValue
      if startIndex < 0 then
          printfn $"Unable to find {startValue} in the collection."
      else
          // Display all numbers from startIndex on.
          printfn $"Displaying values greater than or equal to {startValue}:"
          for i = startIndex to numbers.Count - 1 do
              printf $"    {numbers[i]}"
  
  let startValue =
      let args = Environment.GetCommandLineArgs()
      if args.Length < 2 then
          2
      else
          match Int32.TryParse args[1] with
          | true, v -> v
          | _ -> 2
  
  showValues startValue
  
  // The example displays the following output if the user supplies
  // 7 as a command-line parameter:
  //      Unable to find 7 in the collection.
  

  Imports System.Collections.Generic
  
  Module Example
     Dim numbers As New List(Of Integer)
  
     Public Sub Main()
        Dim startValue As Integer 
        Dim args() As String = Environment.GetCommandLineArgs()
        If args.Length < 2 Then
           startValue = 2
        Else
           If Not Int32.TryParse(args(1), startValue) Then
              startValue = 2
           End If   
        End If
        ShowValues(startValue)
     End Sub
     
     Private Sub ShowValues(startValue As Integer)   
        ' Create a collection with numeric values.
        If numbers.Count = 0 Then 
           numbers.AddRange( { 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22} )
        End If   
        ' Get the index of startValue.
        Dim startIndex As Integer = numbers.IndexOf(startValue)
        If startIndex < 0 Then
           Console.WriteLine("Unable to find {0} in the collection.", startValue)
        Else
           ' Display all numbers from startIndex on.
           Console.WriteLine("Displaying values greater than or equal to {0}:",
                          startValue)
           For ctr As Integer = startIndex To numbers.Count - 1
              Console.Write("    {0}", numbers(ctr))
           Next
        End If
     End Sub
  End Module
  ' The example displays the following output if the user supplies
  '       Unable to find 7 in the collection.
  

• Trying to use or enumerate a result set, collection, or array returned by a query without testing whether the returned object has any valid data.

• Using a computed value to define the starting index, the ending index, or the number of items to be iterated. If the result of the computation is unexpected, it might result in an IndexOutOfRangeException exception. You should check your program's logic in calculating the index value and validate the value before iterating the array or collection. The following conditions must all be true; otherwise, an IndexOutOfRangeException exception is thrown:

  • The starting index must be greater than or equal to Array.GetLowerBound for the dimension of the array that you want to iterate, or greater than or equal to 0 for a collection.

  • The ending index cannot exceed Array.GetUpperBound for the dimension of the array that you want to iterate, or cannot be greater than or equal to the Count property of a collection.

  • The following equation must be true for the dimension of the array that you want to iterate:

    start_index >= lower_bound And start_index + items_to_iterate - 1 <= upper_bound  
    

    For a collection, the following equation must be true:

    start_index >= 0 And start_index + items_to_iterate <= Count  
    

    Tip

    The starting index of an array or collection can never be a negative number.

• Assuming that an array must be zero-based. Arrays that are not zero-based can be created by the Array.CreateInstance(Type, Int32[], Int32[]) method and can be returned by COM interop, although they aren't CLS-compliant. The following example illustrates the IndexOutOfRangeException that is thrown when you try to iterate a non-zero-based array created by the Array.CreateInstance(Type, Int32[], Int32[]) method.

  using System;
  
  public class Example
  {
     public static void Main()
     {
        Array values = Array.CreateInstance(typeof(int), new int[] { 10 },
                                            new int[] { 1 });
        int value = 2;
        // Assign values.
        for (int ctr = 0; ctr < values.Length; ctr++) {
           values.SetValue(value, ctr);
           value *= 2;
        }
  
        // Display values.
        for (int ctr = 0; ctr < values.Length; ctr++)
           Console.Write("{0}    ", values.GetValue(ctr));
     }
  }
  // The example displays the following output:
  //    Unhandled Exception:
  //    System.IndexOutOfRangeException: Index was outside the bounds of the array.
  //       at System.Array.InternalGetReference(Void* elemRef, Int32 rank, Int32* pIndices)
  //       at System.Array.SetValue(Object value, Int32 index)
  //       at Example.Main()
  

  open System
  
  let values = 
      Array.CreateInstance(typeof<int>, [| 10 |], [| 1 |])
  let mutable value = 2
  // Assign values.
  for i = 0 to values.Length - 1 do
      values.SetValue(value, i)
      value <- value * 2
  
  // Display values.
  for i = 0 to values.Length - 1 do
      printf $"{values.GetValue i}    "
  
  // The example displays the following output:
  //    Unhandled Exception:
  //    System.IndexOutOfRangeException: Index was outside the bounds of the array.
  //       at System.Array.InternalGetReference(Void* elemRef, Int32 rank, Int32* pIndices)
  //       at System.Array.SetValue(Object value, Int32 index)
  //       at <StartupCode$fs>.main@()
  

  Module Example
     Public Sub Main()
        Dim values = Array.CreateInstance(GetType(Integer), { 10 }, { 1 })
        Dim value As Integer = 2
        ' Assign values.
        For ctr As Integer = 0 To values.Length - 1
           values(ctr) = value
           value *= 2
        Next
        
        ' Display values.
        For ctr As Integer = 0 To values.Length - 1
           Console.Write("{0}    ", values(ctr))
        Next
     End Sub
  End Module
  ' The example displays the following output:
  '    Unhandled Exception: 
  '    System.IndexOutOfRangeException: Index was outside the bounds of the array.
  '       at System.Array.InternalGetReference(Void* elemRef, Int32 rank, Int32* pIndices)
  '       at System.Array.SetValue(Object value, Int32 index)
  '       at Microsoft.VisualBasic.CompilerServices.NewLateBinding.ObjectLateIndexSetComplex(Obje
  '    ct Instance, Object[] Arguments, String[] ArgumentNames, Boolean OptimisticSet, Boolean RV
  '    alueBase)
  '       at Microsoft.VisualBasic.CompilerServices.NewLateBinding.LateIndexSet(Object Instance,
  '    Object[] Arguments, String[] ArgumentNames)
  '       at Example.Main()
  

  To correct the error, as the following example does, you can call the GetLowerBound method instead of making assumptions about the starting index of an array.

  using System;
  
  public class Example
  {
     public static void Main()
     {
        Array values = Array.CreateInstance(typeof(int), new int[] { 10 },
                                            new int[] { 1 });
        int value = 2;
        // Assign values.
        for (int ctr = values.GetLowerBound(0); ctr <= values.GetUpperBound(0); ctr++) {
           values.SetValue(value, ctr);
           value *= 2;
        }
  
        // Display values.
        for (int ctr = values.GetLowerBound(0); ctr <= values.GetUpperBound(0); ctr++)
           Console.Write("{0}    ", values.GetValue(ctr));
     }
  }
  // The example displays the following output:
  //        2    4    8    16    32    64    128    256    512    1024
  

  open System
  
  let values = 
      Array.CreateInstance(typeof<int>, [| 10 |], [| 1 |])
  let mutable value = 2
  // Assign values.
  for i = values.GetLowerBound 0 to values.GetUpperBound 0 do
      values.SetValue(value, i)
      value <- value * 2
  
  // Display values.
  for i = values.GetLowerBound 0 to values.GetUpperBound 0 do
      printf $"{values.GetValue i}    "
  // The example displays the following output:
  //        2    4    8    16    32    64    128    256    512    1024
  

  Module Example
     Public Sub Main()
        Dim values = Array.CreateInstance(GetType(Integer), { 10 }, { 1 })
        Dim value As Integer = 2
        ' Assign values.
        For ctr As Integer = values.GetLowerBound(0) To values.GetUpperBound(0)
           values(ctr) = value
           value *= 2
        Next
        
        ' Display values.
        For ctr As Integer = values.GetLowerBound(0) To values.GetUpperBound(0)
           Console.Write("{0}    ", values(ctr))
        Next
     End Sub
  End Module
  ' The example displays the following output:
  '       2    4    8    16    32    64    128    256    512    1024
  

  Note that when you call the GetLowerBound method to get the starting index of an array, you should also call the Array.GetUpperBound(Int32) method to get its ending index.

• Confusing an index and the value at that index in a numeric array or collection. This issue usually occurs when using the foreach statement (in C#), the for...in statement (in F#), or the For Each statement (in Visual Basic). The following example illustrates the problem.

  using System;
  
  public class Example
  {
     public static void Main()
     {
        // Generate array of random values.
        int[] values = PopulateArray(5, 10);
        // Display each element in the array.
        foreach (var value in values)
           Console.Write("{0}   ", values[value]);
     }
  
     private static int[] PopulateArray(int items, int maxValue)
     {
        int[] values = new int[items];
        Random rnd = new Random();
        for (int ctr = 0; ctr < items; ctr++)
           values[ctr] = rnd.Next(0, maxValue + 1);
  
        return values;
     }
  }
  // The example displays output like the following:
  //    6   4   4
  //    Unhandled Exception: System.IndexOutOfRangeException:
  //    Index was outside the bounds of the array.
  //       at Example.Main()
  

  open System
  
  let populateArray items maxValue =
      let rnd = Random()
      [| for i = 0 to items - 1 do
          rnd.Next(0, maxValue + 1) |]
  
  // Generate array of random values.
  let values = populateArray 5 10
  // Display each element in the array.
  for value in values do
      printf $"{values[value]}   "
  
  // The example displays output like the following:
  //    6   4   4
  //    Unhandled Exception: System.IndexOutOfRangeException:
  //    Index was outside the bounds of the array.
  //       at <StartupCode$fs>.main@()
  

  Module Example
     Public Sub Main()
        ' Generate array of random values.
        Dim values() As Integer = PopulateArray(5, 10)
        ' Display each element in the array.
        For Each value In values
           Console.Write("{0}   ", values(value))
        Next
     End Sub
     
     Private Function PopulateArray(items As Integer, 
                                    maxValue As Integer) As Integer()
        Dim values(items - 1) As Integer
        Dim rnd As New Random()
        For ctr As Integer = 0 To items - 1
           values(ctr) = rnd.Next(0, maxValue + 1)   
        Next    
        Return values                                                      
     End Function
  End Module
  ' The example displays output like the following:
  '    6   4   4
  '    Unhandled Exception: System.IndexOutOfRangeException: 
  '    Index was outside the bounds of the array.
  '       at Example.Main()
  

  The iteration construct returns each value in an array or collection, not its index. To eliminate the exception, use this code.

  using System;
  
  public class Example
  {
     public static void Main()
     {
        // Generate array of random values.
        int[] values = PopulateArray(5, 10);
        // Display each element in the array.
        foreach (var value in values)
           Console.Write("{0}   ", value);
     }
  
     private static int[] PopulateArray(int items, int maxValue)
     {
        int[] values = new int[items];
        Random rnd = new Random();
        for (int ctr = 0; ctr < items; ctr++)
           values[ctr] = rnd.Next(0, maxValue + 1);
  
        return values;
     }
  }
  // The example displays output like the following:
  //        10   6   7   5   8
  

  open System
  
  let populateArray items maxValue =
      let rnd = Random()
      [| for i = 0 to items - 1 do
          rnd.Next(0, maxValue + 1) |]
  
  // Generate array of random values.
  let values = populateArray 5 10
  // Display each element in the array.
  for value in values do
      printf $"{value}   "
      
  // The example displays output like the following:
  //        10   6   7   5   8
  

  Module Example
     Public Sub Main()
        ' Generate array of random values.
        Dim values() As Integer = PopulateArray(5, 10)
        ' Display each element in the array.
        For Each value In values
           Console.Write("{0}   ", value)
        Next
     End Sub
     
     Private Function PopulateArray(items As Integer, 
                                    maxValue As Integer) As Integer()
        Dim values(items - 1) As Integer
        Dim rnd As New Random()
        For ctr As Integer = 0 To items - 1
           values(ctr) = rnd.Next(0, maxValue + 1)   
        Next    
        Return values                                                      
     End Function
  End Module
  ' The example displays output like the following:
  '       10   6   7   5   8
  

• Providing an invalid column name to the DataView.Sort property.

• Violating thread safety. Operations such as reading from the same StreamReader object, writing to the same StreamWriter object from multiple threads, or enumerating the objects in a Hashtable from different threads can throw an IndexOutOfRangeException if the object isn't accessed in a thread-safe way. This exception is typically intermittent because it relies on a race condition.

Using hard-coded index values to manipulate an array is likely to throw an exception if the index value is incorrect or invalid, or if the size of the array being manipulation is unexpected. To prevent an operation from throwing an IndexOutOfRangeException exception, you can do the following:

• Iterate the elements of the array using the foreach statement (in C#), the for...in statement (in F#), or the For Each...Next construct (in Visual Basic) instead of iterating elements by index.

• Iterate the elements by index starting with the index returned by the Array.GetLowerBound method and ending with the index returned by the Array.GetUpperBound method.

• If you are assigning elements in one array to another, ensure that the target array has at least as many elements as the source array by comparing their Array.Length properties.

For a list of initial property values for an instance of IndexOutOfRangeException, see the IndexOutOfRangeException constructors.

The following intermediate language (IL) instructions throw IndexOutOfRangeException:

• ldelem.<type>

• ldelema

• stelem.<type>

IndexOutOfRangeException uses the HRESULT COR_E_INDEXOUTOFRANGE, which has the value 0x80131508.

Constructors

Properties

Methods

Events

Applies to

See also

• Exception
• Handling and throwing exceptions in .NET