IndexOutOfRangeException Classe

Définition

Exception levée lors d’une tentative d’accès à un élément d’un tableau ou d’une collection ayant un index en dehors de ses limites.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
Héritage
IndexOutOfRangeException
Attributs

Remarques

Une IndexOutOfRangeException exception est levée lorsqu’un index non valide est utilisé pour accéder à un membre d’un tableau ou d’une collection, ou pour lire ou écrire à partir d’un emplacement particulier dans une mémoire tampon.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. Cette exception hérite de la Exception classe, mais n’ajoute aucun membre unique.This exception inherits from the Exception class but adds no unique members.

En règle générale IndexOutOfRangeException , une exception est levée suite à une erreur du développeur.Typically, an IndexOutOfRangeException exception is thrown as a result of developer error. Au lieu de gérer l’exception, vous devez diagnostiquer la cause de l’erreur et corriger votre code.Instead of handling the exception, you should diagnose the cause of the error and correct your code. Les causes les plus courantes de l’erreur sont les suivantes:The most common causes of the error are:

  • En oubliant que la limite supérieure d’une collection ou d’un tableau de base zéro est inférieure d’une unité à son nombre de membres ou d’éléments, comme l’illustre l’exemple suivant.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()
    

    Pour corriger l’erreur, vous pouvez utiliser un code semblable au suivant.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'
    

    Sinon, au lieu d’itérer tous les éléments du tableau par leur index, vous pouvez utiliser l' foreach instruction (dans C#) ou l' For Each instruction (dans 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).

  • Tentative d’assignation d’un élément de tableau à un autre tableau qui n’a pas été dimensionné correctement et qui a moins d’éléments que le tableau d’origine.Attempting to assign an array element to another array that has not been adequately dimensioned and that has fewer elements than the original array. L’exemple suivant essaie d’assigner le dernier élément value1 du tableau au même élément dans le value2 tableau.The following example attempts to assign the last element in the value1 array to the same element in the value2 array. Toutefois, le value2 tableau a été incorrectement dimensionné pour comporter six éléments au lieu de sept.However, the value2 array has been incorrectly dimensioned to have six instead of seven elements. Par conséquent, l’assignation lève une IndexOutOfRangeException exception.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()
    
  • Utilisation d’une valeur retournée par une méthode de recherche pour itérer une partie d’un tableau ou d’une collection en commençant à une position d’index particulière.Using a value returned by a search method to iterate a portion of an array or collection starting at a particular index position. Si vous oubliez de vérifier si l’opération de recherche a trouvé une correspondance, le runtime lève IndexOutOfRangeException une exception, comme illustré dans cet exemple.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()
    

    Dans ce cas, la List<T>.IndexOf méthode retourne-1, qui est une valeur d’index non valide, lorsqu’il ne parvient pas à trouver une correspondance.In this case, the List<T>.IndexOf method returns -1, which is an invalid index value, when it fails to find a match. Pour corriger cette erreur, vérifiez la valeur de retour de la méthode de recherche avant d’itérer le tableau, comme illustré dans cet exemple.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.
    
  • Tentative d’utilisation ou d’énumération d’un jeu de résultats, d’une collection ou d’un tableau retourné par une requête sans vérifier si les données de l’objet retourné sont valides.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.

  • Utilisation d’une valeur calculée pour définir l’index de départ, l’index de fin ou le nombre d’éléments à itérer.Using a computed value to define the starting index, the ending index, or the number of items to be iterated. Si le résultat du calcul est inattendu, cela peut entraîner une IndexOutOfRangeException exception.If the result of the computation is unexpected, it might result in an IndexOutOfRangeException exception. Vous devez vérifier la logique de votre programme dans le calcul de la valeur d’index et valider la valeur avant d’itérer le tableau ou la collection.You should check your program's logic in calculating the index value and validate the value before iterating the array or collection. Les conditions suivantes doivent toutes être vraies: dans le cas IndexOutOfRangeException contraire, une exception est levée:The following conditions must all be true; otherwise, an IndexOutOfRangeException exception is thrown:

    • L’index de départ doit être supérieur ou égal à Array.GetLowerBound pour la dimension du tableau que vous souhaitez itérer, ou supérieure ou égale à 0 pour une collection.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’index de fin ne Array.GetUpperBound peut pas être supérieur à la dimension du tableau que vous souhaitez itérer, ou ne peut pas être supérieur ou Count égal à la propriété d’une 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.

    • L’équation suivante doit être vraie pour la dimension du tableau que vous souhaitez itérer: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  
      

      Pour une collection, l’équation suivante doit être vraie:For a collection, the following equation must be true:

      start_index >= 0 And start_index + items_to_iterate <= Count  
      

      Conseil

      L’index de départ d’un tableau ou d’une collection ne peut jamais être un nombre négatif.The starting index of an array or collection can never be a negative number.

  • En supposant qu’un tableau doit être de base zéro.Assuming that an array must be zero-based. Les tableaux qui ne sont pas de base zéro peuvent être créés par Array.CreateInstance(Type, Int32[], Int32[]) la méthode et peuvent être retournés par COM Interop, bien qu’ils ne soient pas conformes à 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. L’exemple suivant illustre l' IndexOutOfRangeException exception qui est levée lorsque vous essayez d’itérer un tableau de base différente de zéro créé par la Array.CreateInstance(Type, Int32[], Int32[]) méthode.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()
    

    Pour corriger l’erreur, comme dans l’exemple suivant, vous pouvez appeler la GetLowerBound méthode au lieu de faire des hypothèses sur l’index de départ d’un tableau.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
    

    Notez que lorsque vous appelez la GetLowerBound méthode pour récupérer l’index de départ d’un tableau, vous devez également appeler Array.GetUpperBound(Int32) la méthode pour récupérer son index de fin.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.

  • Confusion entre un index et la valeur de cet index dans un tableau ou une collection numérique.Confusing an index and the value at that index in a numeric array or collection. Ce problème se produit généralement lors de foreach l’utilisation de C#l’instruction ( For Each dans) ou de l’instruction (dans Visual Basic).This issue usually occurs when using the foreach statement (in C#) or the For Each statement (in Visual Basic). L'exemple de code suivant illustre le problème.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()
    

    La construction d’itération retourne chaque valeur dans un tableau ou une collection, et non dans son index.The iteration construct returns each value in an array or collection, not its index. Pour éliminer l’exception, utilisez ce code.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
    
  • Attribution d’un nom de colonne non DataView.Sort valide à la propriété.Providing an invalid column name to the DataView.Sort property.

  • Violation de la sécurité des threads.Violating thread safety. Les opérations telles que la lecture à StreamReader partir du même objet, l' StreamWriter écriture dans le même objet à partir de plusieurs threads, Hashtable ou l’énumération des objets IndexOutOfRangeException dans un à partir de différents threads peuvent lever une si l’objet n’est pas accessible dans une méthode 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. Cette exception est généralement intermittente, car elle s’appuie sur une condition de concurrence.This exception is typically intermittent because it relies on a race condition.

L’utilisation de valeurs d’index codées en dur pour manipuler un tableau est susceptible de lever une exception si la valeur d’index est incorrecte ou non valide, ou si la taille du tableau en cours de manipulation est inattendue.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. Pour empêcher une opération de lever une IndexOutOfRangeException exception, vous pouvez effectuer les opérations suivantes:To prevent an operation from throwing an IndexOutOfRangeException exception, you can do the following:

  • Itérez les éléments du tableau à l’aide de l’instruction foreach C#(dans) ou de l’instruction for each... Construction suivante (en Visual Basic) au lieu d’itérer les éléments par index.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.

  • Itère les éléments par index en commençant par l’index retourné par Array.GetLowerBound la méthode et en terminant par l’index Array.GetUpperBound retourné par la méthode.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.

  • Si vous assignez des éléments d’un tableau à un autre, vérifiez que le tableau cible a au moins autant d’éléments que le tableau source en Array.Length comparant leurs propriétés.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.

Pour obtenir la liste des valeurs initiales des propriétés d’une instance de IndexOutOfRangeException, consultez le IndexOutOfRangeException constructeurs.For a list of initial property values for an instance of IndexOutOfRangeException, see the IndexOutOfRangeException constructors.

Les instructions de langage intermédiaire suivantes lèvent IndexOutOfRangeException:The following intermediate language (IL) instructions throw IndexOutOfRangeException:

  • ldelem. <> de typeldelem.<type>

  • ldelemaldelema

  • stelem. <> de typestelem.<type>

IndexOutOfRangeExceptionutilise le HRESULT COR_E_INDEXOUTOFRANGE, qui a la valeur 0x80131508.IndexOutOfRangeException uses the HRESULT COR_E_INDEXOUTOFRANGE, which has the value 0x80131508.

Constructeurs

IndexOutOfRangeException()

Initialise une nouvelle instance de la classe IndexOutOfRangeException.Initializes a new instance of the IndexOutOfRangeException class.

IndexOutOfRangeException(String)

Initialise une nouvelle instance de la classe IndexOutOfRangeException avec un message d'erreur spécifié.Initializes a new instance of the IndexOutOfRangeException class with a specified error message.

IndexOutOfRangeException(String, Exception)

Initialise une nouvelle instance de la classe IndexOutOfRangeException avec un message d'erreur spécifié et une référence à l'exception interne ayant provoqué cette exception.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.

Propriétés

Data

Obtient une collection de paires clé/valeur qui fournissent des informations supplémentaires définies par l’utilisateur sur l’exception.Gets a collection of key/value pairs that provide additional user-defined information about the exception.

(Hérité de Exception)
HelpLink

Obtient ou définit un lien vers le fichier d'aide associé à cette exception.Gets or sets a link to the help file associated with this exception.

(Hérité de Exception)
HResult

Obtient ou définit HRESULT, valeur numérique codée qui est assignée à une exception spécifique.Gets or sets HRESULT, a coded numerical value that is assigned to a specific exception.

(Hérité de Exception)
InnerException

Obtient l'instance Exception qui a provoqué l'exception actuelle.Gets the Exception instance that caused the current exception.

(Hérité de Exception)
Message

Obtient un message qui décrit l'exception actuelle.Gets a message that describes the current exception.

(Hérité de Exception)
Source

Obtient ou définit le nom de l'application ou de l'objet qui est à l'origine de l'erreur.Gets or sets the name of the application or the object that causes the error.

(Hérité de Exception)
StackTrace

Obtient une représentation sous forme de chaîne des frames immédiats sur la pile des appels.Gets a string representation of the immediate frames on the call stack.

(Hérité de Exception)
TargetSite

Obtient la méthode qui lève l'exception actuelle.Gets the method that throws the current exception.

(Hérité de Exception)

Méthodes

Equals(Object)

Détermine si l'objet spécifié est identique à l'objet actuel.Determines whether the specified object is equal to the current object.

(Hérité de Object)
GetBaseException()

En cas de substitution dans une classe dérivée, retourne la Exception qui est à l'origine d'une ou de plusieurs exceptions ultérieures.When overridden in a derived class, returns the Exception that is the root cause of one or more subsequent exceptions.

(Hérité de Exception)
GetHashCode()

Fait office de fonction de hachage par défaut.Serves as the default hash function.

(Hérité de Object)
GetObjectData(SerializationInfo, StreamingContext)

En cas de substitution dans une classe dérivée, définit SerializationInfo avec des informations sur l'exception.When overridden in a derived class, sets the SerializationInfo with information about the exception.

(Hérité de Exception)
GetType()

Obtient le type au moment de l'exécution de l'instance actuelle.Gets the runtime type of the current instance.

(Hérité de Exception)
MemberwiseClone()

Crée une copie superficielle de l'objet Object actuel.Creates a shallow copy of the current Object.

(Hérité de Object)
ToString()

Crée et retourne une chaîne représentant l'exception actuelle.Creates and returns a string representation of the current exception.

(Hérité de Exception)

Événements

SerializeObjectState

Se produit quand une exception est sérialisée pour créer un objet d'état d'exception qui contient des données sérialisées concernant l'exception.Occurs when an exception is serialized to create an exception state object that contains serialized data about the exception.

(Hérité de Exception)

S’applique à

Voir aussi