IndexOutOfRangeException IndexOutOfRangeException IndexOutOfRangeException IndexOutOfRangeException Class

Definizione

Eccezione generata se si tenta di accedere a un elemento di una matrice o una raccolta con un indice che non rientra nei limiti.The exception that is thrown when an attempt is made to access an element of an array or collection with an index that is outside its bounds.

public ref class IndexOutOfRangeException sealed : SystemException
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public sealed class IndexOutOfRangeException : SystemException
type IndexOutOfRangeException = class
    inherit SystemException
Public NotInheritable Class IndexOutOfRangeException
Inherits SystemException
Ereditarietà
IndexOutOfRangeExceptionIndexOutOfRangeExceptionIndexOutOfRangeExceptionIndexOutOfRangeException
Attributi

Commenti

Un IndexOutOfRangeException eccezione viene generata quando un indice non valido viene utilizzato per accedere a un membro di una matrice o una raccolta, o di lettura o scrittura da una posizione specifica in un buffer.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. Questa eccezione eredita il Exception classe non aggiunge ma nessun membro univoco.This exception inherits from the Exception class but adds no unique members.

In genere, un IndexOutOfRangeException eccezione viene generata in seguito a errore per gli sviluppatori.Typically, an IndexOutOfRangeException exception is thrown as a result of developer error. Invece di gestire l'eccezione, è necessario diagnosticare la causa dell'errore e correggere il codice.Instead of handling the exception, you should diagnose the cause of the error and correct your code. Le cause più comuni dell'errore sono:The most common causes of the error are:

  • Se si dimentica che il limite superiore di una raccolta o una matrice in base zero è una minore relativo numero di membri o elementi, come illustrato nell'esempio seguente viene illustrato.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()
    
    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()
    

    Per correggere l'errore, è possibile usare codice simile al seguente.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'
    
    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'
    

    In alternativa, anziché l'iterazione di tutti gli elementi nella matrice in base all'indice, è possibile usare la foreach istruzione (in C#) o For Each istruzione (in Visual Basic).Alternately, instead of iterating all the elements in the array by their index, you can use the foreach statement (in C#) or the For Each statement (in Visual Basic).

  • È stato effettuato un tentativo di assegnare un elemento della matrice in un'altra matrice non stata dimensionata in modo adeguato e che presenta meno elementi dalla matrice originale.Attempting to assign an array element to another array that has not been adequately dimensioned and that has fewer elements than the original array. Nell'esempio seguente tenta di assegnare all'ultimo elemento di value1 allo stesso elemento nella matrice il value2 matrice.The following example attempts to assign the last element in the value1 array to the same element in the value2 array. Tuttavia, il value2 matrice ha stata dimensionata in modo non corretto per sei invece di sette elementi.However, the value2 array has been incorrectly dimensioned to have six instead of seven elements. Di conseguenza, l'assegnazione genera un IndexOutOfRangeException eccezione.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()
    
    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()
    
  • Utilizzo di un valore restituito da un metodo di ricerca per eseguire l'iterazione di una parte di una matrice o raccolta a partire da una posizione di indice specifico.Using a value returned by a search method to iterate a portion of an array or collection starting at a particular index position. Se si dimentica di controllare se l'operazione di ricerca è stata trovata una corrispondenza, il runtime genera un IndexOutOfRangeException eccezione, come illustrato in questo esempio.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()
    
    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 questo caso, il List<T>.IndexOf metodo restituisce -1, che è un valore di indice non valido, se non è possibile trovare una corrispondenza.In this case, the List<T>.IndexOf method returns -1, which is an invalid index value, when it fails to find a match. Per correggere questo errore, controllare il valore restituito del metodo di ricerca esegue l'iterazione nella matrice, come illustrato in questo esempio.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.
    
    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.
    
  • Tentativo di utilizzare o enumerare un set di risultati, insieme o matrice restituita da una query senza verificare se l'oggetto restituito include dati validi.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.

  • Usando un valore calcolato per definire l'indice iniziale, l'indice finale o il numero di elementi per eseguire l'iterazione.Using a computed value to define the starting index, the ending index, or the number of items to be iterated. Se il risultato del calcolo è imprevisto, ciò potrebbe comportare un IndexOutOfRangeException eccezione.If the result of the computation is unexpected, it might result in an IndexOutOfRangeException exception. È necessario controllare per la logica del programma nel calcolo del valore di indice e convalidare il valore prima di iterare la matrice o raccolta.You should check your program's logic in calculating the index value and validate the value before iterating the array or collection. Le condizioni seguenti devono essere tutti true. in caso contrario, un IndexOutOfRangeException eccezione:The following conditions must all be true; otherwise, an IndexOutOfRangeException exception is thrown:

    • L'indice iniziale deve essere maggiore o uguale a Array.GetLowerBound per la dimensione della matrice che si desidera eseguire l'iterazione, oppure maggiore o uguale a 0 per una raccolta.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.

    • L'indice finale non può superare Array.GetUpperBound per la dimensione della matrice che si desidera eseguire l'iterazione, o non può essere maggiore o uguale al Count proprietà di una raccolta.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.

    • L'equazione seguente deve essere true per la dimensione della matrice che si desidera eseguire l'iterazione: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  
      

      Per una raccolta, l'equazione seguente deve essere true:For a collection, the following equation must be true:

      start_index >= 0 And start_index + items_to_iterate <= Count  
      

      Suggerimento

      Indice iniziale di una matrice o raccolta non può mai essere un numero negativo.The starting index of an array or collection can never be a negative number.

  • Supponendo che una matrice deve essere in base zero.Assuming that an array must be zero-based. È possibile creare matrici che non sono in base zero dal Array.CreateInstance(Type, Int32[], Int32[]) metodo e può essere restituito dall'interoperabilità COM, anche se non sono conformi a CLS.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. Nell'esempio seguente viene illustrato il IndexOutOfRangeException che viene generata quando si prova a eseguire l'iterazione di una matrice non basate su zero creata dal Array.CreateInstance(Type, Int32[], Int32[]) (metodo).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()
    
    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()
    

    Per correggere l'errore, come avviene nell'esempio seguente, è possibile chiamare il GetLowerBound metodo invece di fare ipotesi sull'indice iniziale della matrice.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
    
    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
    

    Si noti che quando si chiama il GetLowerBound metodo per ottenere l'indice iniziale di una matrice, è anche necessario chiamare il Array.GetUpperBound(Int32) metodo per ottenere il relativo indice finale.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.

  • Un processo piuttosto complesso un indice e il valore in corrispondenza di tale indice in un oggetto array numerico o una raccolta.Confusing an index and the value at that index in a numeric array or collection. Questo problema si verifica in genere quando si usa la foreach istruzione (in C#) o For Each istruzione (in Visual Basic).This issue usually occurs when using the foreach statement (in C#) or the For Each statement (in Visual Basic). Nell'esempio che segue viene illustrato il problema.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()
    
    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()
    

    Il costrutto dell'iterazione restituisce ogni valore in una matrice o raccolta, non il relativo indice.The iteration construct returns each value in an array or collection, not its index. Per eliminare l'eccezione, usare questo codice.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
    
    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
    
  • Fornire un nome di colonna non valido per il DataView.Sort proprietà.Providing an invalid column name to the DataView.Sort property.

  • Violare la sicurezza dei thread.Violating thread safety. Operazioni quali la lettura dalla stessa StreamReader oggetti, la scrittura alla stessa StreamWriter dell'oggetto da più thread o l'enumerazione di oggetti in un Hashtable da thread diversi possono generare un IndexOutOfRangeException se l'oggetto non è accessibile un modo thread-safe.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. Questa eccezione viene in genere intermittente perché si basa su una race condition.This exception is typically intermittent because it relies on a race condition.

Usando i valori di indice a livello di codice per modificare una matrice è probabile che generino un'eccezione se il valore di indice è non corretto o non valido o se la dimensione della matrice in fase di modifica è imprevista.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. Per impedire che un'operazione di generazione di un IndexOutOfRangeException eccezione, è possibile eseguire le operazioni seguenti:To prevent an operation from throwing an IndexOutOfRangeException exception, you can do the following:

  • Iterare gli elementi della matrice utilizzando il foreach istruzione (in C#) o For Each... Avanti costruire (in Visual Basic) anziché l'iterazione di elementi in base all'indice.Iterate the elements of the array using the foreach statement (in C#) or the For Each...Next construct (in Visual Basic) instead of iterating elements by index.

  • Iterare gli elementi in base all'indice inizia con l'indice restituito dal Array.GetLowerBound metodo iniziale e finendo con l'indice restituito dal Array.GetUpperBound (metodo).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.

  • Se si assegnano gli elementi in una matrice a un altro, verificare che la matrice di destinazione abbia almeno un numero di elementi come matrice di origine confrontando i Array.Length proprietà.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.

Per un elenco di valori di proprietà iniziali per un'istanza di IndexOutOfRangeException, vedere il IndexOutOfRangeException costruttori.For a list of initial property values for an instance of IndexOutOfRangeException, see the IndexOutOfRangeException constructors.

Le seguenti istruzioni di linguaggio intermedio (IL) generano IndexOutOfRangeException:The following intermediate language (IL) instructions throw IndexOutOfRangeException:

  • ldelem. <tipo >ldelem.<type>

  • ldelemaldelema

  • stelem. <tipo >stelem.<type>

IndexOutOfRangeException utilizza COR_E_INDEXOUTOFRANGE HRESULT, che ha il valore 0x80131508.IndexOutOfRangeException uses the HRESULT COR_E_INDEXOUTOFRANGE, which has the value 0x80131508.

Costruttori

IndexOutOfRangeException() IndexOutOfRangeException() IndexOutOfRangeException() IndexOutOfRangeException()

Inizializza una nuova istanza della classe IndexOutOfRangeException.Initializes a new instance of the IndexOutOfRangeException class.

IndexOutOfRangeException(String) IndexOutOfRangeException(String) IndexOutOfRangeException(String) IndexOutOfRangeException(String)

Inizializza una nuova istanza della classe IndexOutOfRangeException con un messaggio di errore specificato.Initializes a new instance of the IndexOutOfRangeException class with a specified error message.

IndexOutOfRangeException(String, Exception) IndexOutOfRangeException(String, Exception) IndexOutOfRangeException(String, Exception) IndexOutOfRangeException(String, Exception)

Inizializza una nuova istanza della classe IndexOutOfRangeException con un messaggio di errore specificato e un riferimento all'eccezione interna che è la causa dell'eccezione corrente.Initializes a new instance of the IndexOutOfRangeException class with a specified error message and a reference to the inner exception that is the cause of this exception.

Proprietà

Data Data Data Data

Ottiene una raccolta di coppie chiave-valore che fornisce informazioni aggiuntive definite dall'utente relative all'eccezione.Gets a collection of key/value pairs that provide additional user-defined information about the exception.

(Inherited from Exception)
HelpLink HelpLink HelpLink HelpLink

Ottiene o imposta un collegamento al file della Guida associato all'eccezione.Gets or sets a link to the help file associated with this exception.

(Inherited from Exception)
HResult HResult HResult HResult

Ottiene o imposta HRESULT, un valore numerico codificato che viene assegnato a un'eccezione specifica.Gets or sets HRESULT, a coded numerical value that is assigned to a specific exception.

(Inherited from Exception)
InnerException InnerException InnerException InnerException

Ottiene l'istanza di Exception che ha causato l'eccezione corrente.Gets the Exception instance that caused the current exception.

(Inherited from Exception)
Message Message Message Message

Ottiene un messaggio che descrive l'eccezione corrente.Gets a message that describes the current exception.

(Inherited from Exception)
Source Source Source Source

Ottiene o imposta il nome dell'oggetto o dell'applicazione che ha generato l'errore.Gets or sets the name of the application or the object that causes the error.

(Inherited from Exception)
StackTrace StackTrace StackTrace StackTrace

Ottiene una rappresentazione di stringa dei frame immediati nello stack di chiamate.Gets a string representation of the immediate frames on the call stack.

(Inherited from Exception)
TargetSite TargetSite TargetSite TargetSite

Ottiene il metodo che genera l'eccezione corrente.Gets the method that throws the current exception.

(Inherited from Exception)

Metodi

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente.Determines whether the specified object is equal to the current object.

(Inherited from Object)
GetBaseException() GetBaseException() GetBaseException() GetBaseException()

Se utilizzato come metodo di override in una classe derivata, restituisce l'Exception che è la causa radice di una o più eccezioni successive.When overridden in a derived class, returns the Exception that is the root cause of one or more subsequent exceptions.

(Inherited from Exception)
GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Funge da funzione hash predefinita.Serves as the default hash function.

(Inherited from Object)
GetObjectData(SerializationInfo, StreamingContext) GetObjectData(SerializationInfo, StreamingContext) GetObjectData(SerializationInfo, StreamingContext) GetObjectData(SerializationInfo, StreamingContext)

Quando l'override viene eseguito in una classe derivata, imposta il controllo SerializationInfo per la colonna.When overridden in a derived class, sets the SerializationInfo with information about the exception.

(Inherited from Exception)
GetType() GetType() GetType() GetType()

Ottiene il tipo di runtime dell'istanza corrente.Gets the runtime type of the current instance.

(Inherited from Exception)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.Creates a shallow copy of the current Object.

(Inherited from Object)
ToString() ToString() ToString() ToString()

Crea e restituisce una rappresentazione di stringa dell'eccezione corrente.Creates and returns a string representation of the current exception.

(Inherited from Exception)

Eventi

SerializeObjectState SerializeObjectState SerializeObjectState SerializeObjectState

Si verifica quando un'eccezione viene serializzata per creare un oggetto di stato eccezione contenente i dati serializzati relativi all'eccezione.Occurs when an exception is serialized to create an exception state object that contains serialized data about the exception.

(Inherited from Exception)

Si applica a

Vedi anche