Questo articolo è stato tradotto automaticamente. Per visualizzare l'articolo in inglese, selezionare la casella di controllo Inglese. È possibile anche visualizzare il testo inglese in una finestra popup posizionando il puntatore del mouse sopra il testo.
Traduzione
Inglese

Classe IndexOutOfRangeException

 

Data di pubblicazione: ottobre 2016

Eccezione generata se si tenta di accedere a un elemento di una matrice o una raccolta con un indice che non rientra nei limiti.

Spazio dei nomi:   System
Assembly:  mscorlib (in mscorlib.dll)

System.Object
  System.Exception
    System.SystemException
      System.IndexOutOfRangeException

[SerializableAttribute]
[ComVisibleAttribute(true)]
public sealed class IndexOutOfRangeException : SystemException

NomeDescrizione
System_CAPS_pubmethodIndexOutOfRangeException()

Inizializza una nuova istanza della classe IndexOutOfRangeException.

System_CAPS_pubmethodIndexOutOfRangeException(String)

Inizializza una nuova istanza della classe IndexOutOfRangeException con un messaggio di errore specificato.

System_CAPS_pubmethodIndexOutOfRangeException(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.

NomeDescrizione
System_CAPS_pubpropertyData

Ottiene una raccolta di coppie chiave-valore che fornisce informazioni aggiuntive definite dall'utente relative all'eccezione.(Ereditato da Exception.)

System_CAPS_pubpropertyHelpLink

Ottiene o imposta un collegamento al file della Guida associato all'eccezione.(Ereditato da Exception.)

System_CAPS_pubpropertyHResult

Ottiene o imposta HRESULT, un valore numerico codificato che viene assegnato a un'eccezione specifica.(Ereditato da Exception.)

System_CAPS_pubpropertyInnerException

Ottiene l'istanza di Exception che ha causato l'eccezione corrente.(Ereditato da Exception.)

System_CAPS_pubpropertyMessage

Ottiene un messaggio che descrive l'eccezione corrente.(Ereditato da Exception.)

System_CAPS_pubpropertySource

Ottiene o imposta il nome dell'oggetto o dell'applicazione che ha generato l'errore.(Ereditato da Exception.)

System_CAPS_pubpropertyStackTrace

Ottiene una rappresentazione di stringa dei frame immediati nello stack di chiamate.(Ereditato da Exception.)

System_CAPS_pubpropertyTargetSite

Ottiene il metodo che genera l'eccezione corrente.(Ereditato da Exception.)

NomeDescrizione
System_CAPS_pubmethodEquals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente.(Ereditato da Object.)

System_CAPS_pubmethodGetBaseException()

Quando ne viene eseguito l'override in una classe derivata, restituisce l'Exception che è la causa radice di una o più eccezioni successive.(Ereditato da Exception.)

System_CAPS_pubmethodGetHashCode()

Funge da funzione hash predefinita.(Ereditato da Object.)

System_CAPS_pubmethodGetObjectData(SerializationInfo, StreamingContext)

Quando ne viene eseguito l'override in una classe derivata, imposta il controllo SerializationInfo con le informazioni sull'eccezione.(Ereditato da Exception.)

System_CAPS_pubmethodGetType()

Ottiene il tipo di runtime dell'istanza corrente.(Ereditato da Exception.)

System_CAPS_pubmethodToString()

Crea e restituisce una rappresentazione di stringa dell'eccezione corrente.(Ereditato da Exception.)

Un IndexOutOfRangeException 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 un percorso specifico in un buffer. Questa eccezione eredita la Exception classe ma non aggiunge alcun membri univoci.

In genere, un IndexOutOfRangeException eccezione viene generata come risultato di errore per gli sviluppatori. Invece di gestire l'eccezione, è necessario diagnosticare la causa dell'errore e correggere il codice. Le cause più comuni dell'errore sono:

  • Dimenticare che il limite superiore di una raccolta o una matrice in base zero è una minore il numero di membri e gli elementi, come nell'esempio seguente viene illustrato.

    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()
    

    Per correggere l'errore, è possibile utilizzare codice simile al seguente.

    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'
    

    In alternativa, anziché l'iterazione di tutti gli elementi nella matrice in base all'indice, è possibile utilizzare la (in c#) o (in Visual Basic).

  • Il tentativo di assegnare un elemento di matrice a un'altra matrice non stato dimensionato in modo adeguato e che presenta meno elementi di matrice originale. Nell'esempio seguente tenta di assegnare l'ultimo elemento di value1 allo stesso elemento nella matrice il value2 matrice. Tuttavia, il value2 matrice è stata dimensionata in modo non corretto per sei anziché sette elementi. Di conseguenza, l'assegnazione genera un IndexOutOfRangeException (eccezione).

    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()
    
  • Utilizzo di un valore restituito da un metodo di ricerca per l'iterazione di una parte di una matrice o raccolta a partire da una posizione di indice specifico. 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.

    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()
    

    In questo caso, il List<T>.IndexOf metodo restituisce -1, che è un valore di indice non valido, quando non riesce a trovare una corrispondenza. Per correggere l'errore, controllare il valore restituito del metodo di ricerca prima scorre la matrice, come illustrato in questo esempio.

    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.
    
  • Tenta di utilizzare o enumerare un set di risultati, insieme o matrice restituita da una query senza verificare se l'oggetto restituito contiene dati validi.

  • Utilizzando un valore calcolato per definire l'indice iniziale, l'indice finale o il numero di elementi da scorrere. Se il risultato del calcolo è imprevisto, ma potrebbe causare un IndexOutOfRangeException (eccezione). Controllare la logica del programma per il calcolo del valore di indice e convalidare il valore prima di iterare la matrice o raccolta. Le condizioni seguenti devono essere tutti true. in caso contrario, un IndexOutOfRangeException viene generata un'eccezione:

    • Indice iniziale deve essere maggiore o uguale a Array.GetLowerBound per la dimensione della matrice che si desidera eseguire un'iterazione, oppure maggiore o uguale a 0 per una raccolta.

    • L'indice finale non può superare Array.GetUpperBound per la dimensione della matrice che si desidera eseguire un'iterazione, non può essere maggiore o uguale alla Count proprietà di una raccolta.

    • L'equazione seguente deve essere true per la dimensione della matrice che si desidera eseguire l'iterazione:

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

      Per una raccolta, l'equazione seguente deve essere true:

      start_index >= 0 And start_index + items_to_iterate <= Count
      
      System_CAPS_tipSuggerimento

      Indice iniziale di una matrice o raccolta non può mai essere un numero negativo.

  • Supponendo che una matrice deve essere in base zero. È possibile creare matrici non in base zero di Array.CreateInstance(Type, Int32[], Int32[]) metodo e può essere restituito dall'interoperabilità COM, anche se non sono conformi a CLS. Nell'esempio seguente viene illustrato il IndexOutOfRangeException che viene generata quando si tenta di eseguire l'iterazione di una matrice in base zero non creata dal Array.CreateInstance(Type, Int32[], Int32[]) metodo.

    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()
    

    Per correggere l'errore, come avviene nell'esempio seguente, è possibile chiamare il GetLowerBound metodo anziché fare ipotesi sull'indice iniziale di una matrice.

    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
    

    Si noti che quando si chiama il GetLowerBound per ottenere l'indice iniziale di una matrice, è necessario chiamare anche il Array.GetUpperBound(Int32) per ottenere il relativo indice finale.

  • Confusione tra un indice e il valore di indice in una matrice numerica o una raccolta. Questo problema si verifica in genere quando si utilizza il foreach istruzione (in c#) o For Each istruzione (in Visual Basic). Nell'esempio che segue viene illustrato il problema.

    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()
    

    Il costrutto dell'iterazione restituisce ogni valore in una matrice o raccolta, non il relativo indice. Per eliminare l'eccezione, utilizzare questo codice.

    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
    
  • Specificare un nome di colonna non valido per il DataView.Sort proprietà.

  • Violazione dei thread-safe. Operazioni quali la lettura dalla stessa StreamReader scrittura allo stesso oggetto 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 in modo thread-safe. Questa eccezione viene in genere intermittente perché si basa su una race condition.

Utilizzando i valori di indice a livello di codice per modificare una matrice è probabile che genera un'eccezione se il valore di indice è errato o non valido o se la dimensione dell'array è la modifica è imprevista. Per impedire che un'operazione di generazione di un IndexOutOfRangeException eccezione, è possibile eseguire le operazioni seguenti:

  • Scorrere gli elementi della matrice utilizzando la foreach istruzione (in c#) o For Each...Next costruire (in Visual Basic) anziché l'iterazione di elementi in base all'indice.

  • Scorrere gli elementi in base all'indice a partire dall'indice restituito dal Array.GetLowerBound metodo e terminando con l'indice restituito dal Array.GetUpperBound metodo.

  • Se si utilizzano gli elementi in una matrice a un altro, assicurarsi che la matrice di destinazione disponga almeno tutti gli elementi della matrice di origine confrontando i relativi Array.Length proprietà.

Per un elenco di valori di proprietà iniziali per un'istanza di IndexOutOfRangeException, vedere il IndexOutOfRangeException costruttori.

Le seguenti istruzioni del linguaggio intermedio (IL) generano IndexOutOfRangeException:

  • ldelem. < tipo >

  • ldelema

  • st elem. < tipo >

IndexOutOfRangeException utilizza HRESULT COR_E_INDEXOUTOFRANGE, con valore 0x80131508.

Universal Windows Platform
Disponibile da 8
.NET Framework
Disponibile da 1.1
Libreria di classi portabile
Supportato in: piattaforme .NET portabili
Silverlight
Disponibile da 2.0
Windows Phone Silverlight
Disponibile da 7.0
Windows Phone
Disponibile da 8.1

I membri statici pubblici ( Condiviso in Visual Basic) di questo tipo è thread safe. Non tutti i membri di istanza sono garantiti come thread safe.

Torna all'inizio
Mostra: