ArgumentOutOfRangeException Classe

Définition

public ref class ArgumentOutOfRangeException : ArgumentException

public class ArgumentOutOfRangeException : ArgumentException

[System.Serializable]
public class ArgumentOutOfRangeException : ArgumentException

[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public class ArgumentOutOfRangeException : ArgumentException

type ArgumentOutOfRangeException = class
    inherit ArgumentException

type ArgumentOutOfRangeException = class
    inherit ArgumentException
    interface ISerializable

[<System.Serializable>]
type ArgumentOutOfRangeException = class
    inherit ArgumentException
    interface ISerializable

[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type ArgumentOutOfRangeException = class
    inherit ArgumentException
    interface ISerializable

Public Class ArgumentOutOfRangeException
Inherits ArgumentException

Héritage

Object

Exception

ArgumentException

ArgumentOutOfRangeException

Héritage

Object

Exception

SystemException

ArgumentException

ArgumentOutOfRangeException

Attributs

SerializableAttribute ComVisibleAttribute

Implémente

ISerializable

Exemples

L’exemple suivant définit une classe pour contenir des informations sur un invité invité. Si l’invité a moins de 21 ans, une ArgumentOutOfRangeException exception est levée.

using System;
using static System.Console;

public class Program
{
    public static void Main(string[] args)
    {
        try
        {
            var guest1 = new Guest("Ben", "Miller", 17);
            WriteLine(guest1.GuestInfo);
        }
        catch (ArgumentOutOfRangeException argumentOutOfRangeException)
        {
            WriteLine($"Error: {argumentOutOfRangeException.Message}");
        }
    }
}

class Guest
{
    private const int minimumRequiredAge = 21;

    private string firstName;
    private string lastName;
    private int age;

    public Guest(string firstName, string lastName, int age)
    {
        if (age < minimumRequiredAge)
            throw new ArgumentOutOfRangeException(nameof(age), $"All guests must be {minimumRequiredAge}-years-old or older.");

        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
    }

    public string GuestInfo => $"{firstName} {lastName}, {age}";
}

open System

type Guest(fName: string, lName: string, age: int) =
    let minimumRequiredAge = 21

    do if age < minimumRequiredAge then 
        raise (ArgumentOutOfRangeException(nameof age, $"All guests must be {minimumRequiredAge}-years-old or older."))

    member _.FirstName = fName
    member _.LastName = lName
    member _.GuestInfo() = $"{fName} {lName}, {age}"

try
    let guest1 = Guest("Ben", "Miller", 17);
    printfn $"{guest1.GuestInfo()}"
with
| :? ArgumentOutOfRangeException as e ->
    printfn $"Error: {e.Message}"

Module Module1
   Public Sub Main()
       Try
           Dim guest1 As Guest = New Guest("Ben", "Miller", 17)
           Console.WriteLine(guest1.GuestInfo)
       Catch outOfRange As ArgumentOutOfRangeException
           Console.WriteLine("Error: {0}", outOfRange.Message)
       End Try
   End Sub
End Module

Class Guest
    Private FirstName As String
    Private LastName As String
    Private Age As Integer

    Public Sub New(ByVal fName As String, ByVal lName As String, ByVal age As Integer)
        MyBase.New()
        FirstName = fName
        LastName = lName
        If (age < 21) Then
            Throw New ArgumentOutOfRangeException("age", "All guests must be 21-years-old or older.")
        Else
            age = age
        End If
    End Sub

    Public Function GuestInfo() As String
        Dim gInfo As String = (FirstName + (" " _
                    + (Me.LastName + (", " + Me.Age.ToString))))
        Return gInfo
    End Function
End Class

Remarques

Une ArgumentOutOfRangeException exception est levée lorsqu’une méthode est appelée et qu’au moins un des arguments passés à la méthode n’est pas null et contient une valeur non valide qui n’est pas membre du jeu de valeurs attendu pour l’argument. La ParamName propriété identifie l’argument non valide et la ActualValue propriété, si une valeur est présente, identifie la valeur non valide.

En règle générale, une ArgumentOutOfRangeException erreur de développeur est générée. Au lieu de gérer l’exception dans un try/catch bloc, vous devez éliminer la cause de l’exception ou, si l’argument est retourné par un appel de méthode ou une entrée par l’utilisateur avant d’être passé à la méthode qui lève l’exception, vous devez valider les arguments avant de les transmettre à la méthode.

ArgumentOutOfRangeException est largement utilisé par :

• Classes dans les espaces de System.Collections noms et .System.IO

• La classe Array.

• Méthodes de manipulation de chaîne dans la String classe .

Les conditions dans lesquelles une ArgumentOutOfRangeException exception est levée sont les suivantes :

• Vous récupérez le membre d’une collection par son numéro d’index, et le numéro d’index n’est pas valide.

  Il s’agit de la cause la plus courante d’une ArgumentOutOfRangeException exception. En règle générale, le numéro d’index n’est pas valide pour l’une des quatre raisons suivantes :

  1. La collection n’a aucun membre, et votre code suppose que c’est le cas. L’exemple suivant tente de récupérer le premier élément d’une collection qui ne contient aucun élément :

     using System;
     using System.Collections.Generic;
     
     public class Example4
     {
        public static void Main()
        {
           var list = new List<string>();
           Console.WriteLine("Number of items: {0}", list.Count);
           try {
              Console.WriteLine("The first item: '{0}'", list[0]);
           }
           catch (ArgumentOutOfRangeException e) {
              Console.WriteLine(e.Message);
           }
        }
     }
     // The example displays the following output:
     //   Number of items: 0
     //   Index was out of range. Must be non-negative and less than the size of the collection.
     //   Parameter name: index
     

     open System
     
     
     let list = ResizeArray<string>()
     printfn $"Number of items: {list.Count}"
     try
         printfn $"The first item: '{list[0]}'"
     with 
     | :? ArgumentOutOfRangeException as e ->
         printfn $"{e.Message}"
     
     // The example displays the following output:
     //   Number of items: 0
     //   Index was out of range. Must be non-negative and less than the size of the collection. (Parameter 'index')
     

     Imports System.Collections.Generic
     
     Module Example
        Public Sub Main()
           Dim list As New List(Of String)
           Console.WriteLine("Number of items: {0}", list.Count)
           Try
              Console.WriteLine("The first item: '{0}'", list(0))
           Catch e As ArgumentOutOfRangeException
              Console.WriteLine(e.Message)
           End Try
        End Sub
     End Module
     ' The example displays the following output:
     '   Number of items: 0
     '   Index was out of range. Must be non-negative and less than the size of the collection.
     '   Parameter name: index
     

     Pour empêcher l’exception, case activée si la propriété de Count la collection est supérieure à zéro avant de tenter de récupérer des membres, comme le fait le fragment de code suivant.

     if (list.Count > 0)
        Console.WriteLine("The first item: '{0}'", list[0]);
     

     if list.Count > 0 then
         printfn $"The first item: '{list[0]}'"
     

     If list.Count > 0 Then
        Console.WriteLine("The first item: '{0}'", list(0))
     End If
     

  2. Dans certains cas, l’exception peut se produire parce que vous tentez d’ajouter un membre à une collection en utilisant un index qui n’existe pas, plutôt qu’en appelant la méthode, telle que Add, qui existe à cet effet. L’exemple suivant tente d’ajouter un élément à une collection à l’aide d’un index inexistant plutôt que d’appeler la List<T>.Add méthode .

     using System;
     using System.Collections.Generic;
     
     public class Example13
     {
        public static void Main()
        {
           var numbers = new List<int>();
           numbers.AddRange( new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 20 } );
     
           var squares = new List<int>();
           for (int ctr = 0; ctr < numbers.Count; ctr++)
              squares[ctr] = (int) Math.Pow(numbers[ctr], 2);
        }
     }
     // The example displays the following output:
     //    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.ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument argument, ExceptionResource resource)
     //       at Example.Main()
     

     let numbers = ResizeArray<int>()
     numbers.AddRange [ 0; 1; 2; 3; 4; 5; 6; 7; 8; 9; 20 ]
     
     let squares = ResizeArray<int>()
     for  ctr = 0 to numbers.Count - 1 do
         squares[ctr] <- int (float numbers[ctr] ** 2)
     
     // The example displays the following output:
     //    Unhandled Exception: System.ArgumentOutOfRangeException: Index was out of range. Must be non-negative and less than the size of the collection. (Parameter 'index')
     //       at System.ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument argument, ExceptionResource resource)
     //       at <StartupCode$argumentoutofrangeexception>.$NoElements.main@()
     

     Imports System.Collections.Generic
     
     Module Example
        Public Sub Main()
           Dim numbers As New List(Of Integer)
           numbers.AddRange( { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 20 } )
           
           Dim squares As New List(Of Integer)
           For ctr As Integer = 0 To numbers.Count - 1
              squares(ctr) = CInt(numbers(ctr) ^ 2) 
           Next
        End Sub
     End Module
     ' The example displays the following output:
     '    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.ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument argument, ExceptionResource resource)
     '       at Example.Main()
     

     Le fragment de code suivant corrige cette erreur :

     var squares = new List<int>();
     for (int ctr = 0; ctr < numbers.Count; ctr++)
        squares.Add((int) Math.Pow(numbers[ctr], 2));
     

     let squares = ResizeArray<int>()
     for ctr = 0 to numbers.Count - 1 do
         squares.Add(int (float numbers[ctr] ** 2))
     

     Dim squares As New List(Of Integer)
     For ctr As Integer = 0 To numbers.Count - 1
        squares.Add(CInt(numbers(ctr) ^ 2)) 
     Next
     

  3. Vous tentez de récupérer un élément dont l’index est négatif. Cela se produit généralement parce que vous avez recherché l’index d’un élément particulier dans une collection et que vous avez supposé à tort que la recherche a réussi. Dans l’exemple suivant, l’appel à la List<T>.FindIndex(Predicate<T>) méthode ne parvient pas à trouver une chaîne égale à « Z » et retourne donc -1. Toutefois, il s’agit d’une valeur d’index non valide.

     using System;
     using System.Collections.Generic;
     
     public class Example
     {
        public static void Main()
        {
           var list = new List<string>();
           list.AddRange( new String[] { "A", "B", "C" } );
           // Get the index of the element whose value is "Z".
           int index = list.FindIndex((new StringSearcher("Z")).FindEquals);
           try {
              Console.WriteLine("Index {0} contains '{1}'", index, list[index]);
           }
           catch (ArgumentOutOfRangeException e) {
              Console.WriteLine(e.Message);
           }
        }
     }
     
     internal class StringSearcher
     {
        string value;
     
        public StringSearcher(string value)
        {
           this.value = value;
        }
     
        public bool FindEquals(string s)
        {
           return s.Equals(value, StringComparison.InvariantCulture);
        }
     }
     // The example displays the following output:
     //   Index was out of range. Must be non-negative and less than the size of the collection.
     //   Parameter name: index
     

     open System
     
     module StringSearcher =
         let findEquals (s: string) value =
             s.Equals(value, StringComparison.InvariantCulture)
     
     let list = ResizeArray<string>()
     list.AddRange [ "A"; "B"; "C" ]
     // Get the index of the element whose value is "Z".
     let index = list.FindIndex(StringSearcher.findEquals "Z")
     try 
         printfn $"Index {index} contains '{list[index]}'"
     with 
     | :? ArgumentOutOfRangeException as e ->
         printfn $"{e.Message}" 
     
     // The example displays the following output:
     //   Index was out of range. Must be non-negative and less than the size of the collection. (Parameter 'index')
     

     Imports System.Collections.Generic
     
     Module Example
        Public Sub Main()
           Dim list As New List(Of String) 
           list.AddRange( { "A", "B", "C" } )
           ' Get the index of the element whose value is "Z".
           Dim index As Integer = list.FindIndex(AddressOf (New StringSearcher("Z")).FindEquals)
           Try
              Console.WriteLine("Index {0} contains '{1}'", index, list(index)) 
           Catch e As ArgumentOutOfRangeException
              Console.WriteLine(e.Message)
           End Try
        End Sub
     End Module
     
     Friend Class StringSearcher
        Dim value As String
        
        Public Sub New(value As String)
           Me.value = value
        End Sub
        
        Public Function FindEquals(s As String) As Boolean
           Return s.Equals(value, StringComparison.InvariantCulture) 
        End Function
     End Class
     ' The example displays the following output:
     '   Index was out of range. Must be non-negative and less than the size of the collection.
     '   Parameter name: index
     

     Pour éviter l’exception, case activée que la recherche réussit en vous assurant que l’index retourné est supérieur ou égal à zéro avant de tenter de récupérer l’élément de la collection, comme le fait le fragment de code suivant.

     // Get the index of the element whose value is "Z".
     int index = list.FindIndex((new StringSearcher("Z")).FindEquals);
     if (index >= 0)
        Console.WriteLine("'Z' is found at index {0}", list[index]);
     

     // Get the index of the element whose value is "Z".
     let index = list.FindIndex(StringSearcher.findEquals "Z")
     if index >= 0 then
         printfn $"'Z' is found at index {list[index]}"
     

     ' Get the index of the element whose value is "Z".
     Dim index As Integer = list.FindIndex(AddressOf (New StringSearcher("Z")).FindEquals)
     If index >= 0 Then
        Console.WriteLine("Index {0} contains '{1}'", index, list(index)) 
     End If
     

  4. Vous tentez de récupérer un élément dont l’index est égal à la valeur de la propriété de Count la collection, comme l’illustre l’exemple suivant.

     using System;
     using System.Collections.Generic;
     
     public class Example8
     {
        public static void Main()
        {
           var list = new List<string>();
           list.AddRange( new String[] { "A", "B", "C" } );
           try {
              // Display the elements in the list by index.
              for (int ctr = 0; ctr <= list.Count; ctr++)
                 Console.WriteLine("Index {0}: {1}", ctr, list[ctr]);
           }
           catch (ArgumentOutOfRangeException e) {
              Console.WriteLine(e.Message);
           }
        }
     }
     // The example displays the following output:
     //   Index 0: A
     //   Index 1: B
     //   Index 2: C
     //   Index was out of range. Must be non-negative and less than the size of the collection.
     //   Parameter name: index
     

     open System
     
     let list = ResizeArray<string>()
     list.AddRange [ "A"; "B"; "C" ] 
     try
         // Display the elements in the list by index.
         for i = 0 to list.Count do
             printfn $"Index {i}: {list[i]}"
     with 
     | :? ArgumentOutOfRangeException as e ->
         printfn $"{e.Message}" 
           
     // The example displays the following output:
     //   Index 0: A
     //   Index 1: B
     //   Index 2: C
     //   Index was out of range. Must be non-negative and less than the size of the collection. (Parameter 'index')
     

     Imports System.Collections.Generic
     
     Module Example
        Public Sub Main()
           Dim list As New List(Of String) 
           list.AddRange( { "A", "B", "C" } )
           Try
              ' Display the elements in the list by index.
              For ctr As Integer = 0 To list.Count
                 Console.WriteLine("Index {0}: {1}", ctr, list(ctr)) 
              Next   
           Catch e As ArgumentOutOfRangeException
              Console.WriteLine(e.Message)
           End Try
        End Sub
     End Module
     ' The example displays the following output:
     '   Index 0: A
     '   Index 1: B
     '   Index 2: C
     '   Index was out of range. Must be non-negative and less than the size of the collection.
     '   Parameter name: index
     

     Étant donné que les collections dans .NET utilisent l’indexation de base zéro, le premier élément de la collection se trouve à l’index 0 et le dernier élément est à index Count - 1. Vous pouvez éliminer l’erreur en vous assurant d’accéder au dernier élément à l’index Count - 1, comme le fait le code suivant.

     // Display the elements in the list by index.
     for (int ctr = 0; ctr < list.Count; ctr++)
        Console.WriteLine("Index {0}: {1}", ctr, list[ctr]);
     

     // Display the elements in the list by index.
     for i = 0 to list.Count - 1 do
         printfn $"Index {i}: {list[i]}"
     

     ' Display the elements in the list by index.
     For ctr As Integer = 0 To list.Count - 1 
        Console.WriteLine("Index {0}: {1}", ctr, list(ctr)) 
     Next
     

• Vous tentez d’effectuer une opération de chaîne en appelant une méthode de manipulation de chaîne, et l’index de départ n’existe pas dans la chaîne.

  Les surcharges de méthodes telles que String.Compare, , String.CompareOrdinalString.IndexOf, IndexOfAny, String.InsertString.LastIndexOfAnyString.LastIndexOf, Removeou String.Substring qui vous permettent de spécifier l’index de départ de l’opération nécessitent que l’index soit une position valide dans la chaîne. Les index valides varient de 0 à String.Length - 1.

  Il existe quatre causes courantes de cette ArgumentOutOfRangeException exception :

  1. Vous utilisez une chaîne vide ou String.Empty. Étant donné que sa String.Length propriété renvoie 0, toute tentative de manipulation par index lève une ArgumentOutOfRangeException exception. L’exemple suivant définit une GetFirstCharacter méthode qui retourne le premier caractère d’une chaîne. Si la chaîne est vide, comme la chaîne finale passée à la méthode, la méthode lève une ArgumentOutOfRangeException exception.

     using System;
     
     public class Example1
     {
         public static void Main()
         {
             String[] words = { "the", "today", "tomorrow", " ", "" };
             foreach (var word in words)
                 Console.WriteLine("First character of '{0}': '{1}'",
                                   word, GetFirstCharacter(word));
         }
     
         private static char GetFirstCharacter(string s)
         {
             return s[0];
         }
     }
     // The example displays the following output:
     //    First character of //the//: //t//
     //    First character of //today//: //t//
     //    First character of //tomorrow//: //t//
     //    First character of // //: // //
     //
     //    Unhandled Exception: System.IndexOutOfRangeException: Index was outside the bounds of the array.
     //       at Example.Main()
     

     open System
     
     let getFirstCharacter (s: string) = s[0]
     
     let words = [ "the"; "today"; "tomorrow"; " "; "" ]
     for word in words do
         printfn $"First character of '{word}': '{getFirstCharacter word}'"
     
     // The example displays the following output:
     //    First character of 'the': 't'
     //    First character of 'today': 't'
     //    First character of 'tomorrow': 't'
     //    First character of ' ': ' '
     //
     //    Unhandled Exception: System.IndexOutOfRangeException: Index was outside the bounds of the array.
     //       at <StartupCode$argumentoutofrangeexception>.$EmptyString1.main@()
     

     Module Example
        Public Sub Main()
            Dim words() As String = { "the", "today", "tomorrow", " ", "" }
            For Each word In words
               Console.WriteLine("First character of '{0}': '{1}'", 
                                 word, GetFirstCharacter(word))
            Next                     
        End Sub
        
        Private Function GetFirstCharacter(s As String) As Char
           Return s(0)
        End Function
     End Module
     ' The example displays the following output:
     '    First character of 'the': 't'
     '    First character of 'today': 't'
     '    First character of 'tomorrow': 't'
     '    First character of ' ': ' '
     '    
     '    Unhandled Exception: System.IndexOutOfRangeException: Index was outside the bounds of the array.
     '       at Example.Main()
     

     Vous pouvez éliminer l’exception en testant si la chaîne String.Length est supérieure à zéro ou en appelant la IsNullOrEmpty méthode pour vous assurer que la chaîne n’est pas null ou vide. Le fragment de code suivant effectue cette dernière opération. Dans ce cas, si la chaîne est null ou vide, la GetFirstCharacter méthode retourne U+0000.

     static char GetFirstCharacter(string s)
     {
         if (string.IsNullOrEmpty(s))
             return '\u0000';
         else
             return s[0];
     }
     

     let getFirstCharacter (s: string) =
        if String.IsNullOrEmpty s then
           '\u0000'
        else
           s[0]
     

     Function GetFirstCharacter(s As String) As Char
        If String.IsNullOrEmpty(s) Then 
           Return ChrW(0)
        Else   
           Return s(0)
        End If   
     End Function
     

  2. Vous manipulez une chaîne en fonction de la position d’une sous-chaîne dans cette chaîne, et vous n’avez pas pu déterminer si la sous-chaîne a été trouvée.

     L’exemple suivant extrait le deuxième mot d’une expression de deux mots. Il lève une ArgumentOutOfRangeException exception si l’expression se compose d’un seul mot et ne contient donc pas d’espace incorporé. Cela se produit parce que l’appel à la String.IndexOf(String) méthode retourne -1 pour indiquer que la recherche a échoué, et cette valeur non valide est ensuite passée à la String.Substring(Int32) méthode.

     using System;
     
     public class Example17
     {
        public static void Main()
        {
           String[] phrases = { "ocean blue", "concerned citizen",
                                "runOnPhrase" };
           foreach (var phrase in phrases)
              Console.WriteLine("Second word is {0}", GetSecondWord(phrase));
        }
     
        static string GetSecondWord(string s)
        {
           int pos = s.IndexOf(" ");
           return s.Substring(pos).Trim();
        }
     }
     // The example displays the following output:
     //    Second word is blue
     //    Second word is citizen
     //
     //    Unhandled Exception: System.ArgumentOutOfRangeException: StartIndex cannot be less than zero.
     //    Parameter name: startIndex
     //       at System.String.Substring(Int32 startIndex, Int32 length)
     //       at Example17.GetSecondWord(String s)
     //       at Example17.Main()
     

     let getSecondWord (s: string) =
         let pos = s.IndexOf " "
         s.Substring(pos).Trim()
     
     let phrases = [ "ocean blue"; "concerned citizen"; "runOnPhrase" ]
     for phrase in phrases do
         printfn $"Second word is {getSecondWord phrase}"
     
     // The example displays the following output:
     //    Second word is blue
     //    Second word is citizen
     //
     //    Unhandled Exception: System.ArgumentOutOfRangeException: StartIndex cannot be less than zero. (Parameter 'startIndex')
     //       at System.String.Substring(Int32 startIndex, Int32 length)
     //       at System.String.Substring(Int32 startIndex)
     //       at NoFind1.getSecondWord(String s)
     //       at <StartupCode$argumentoutofrangeexception>.$NoFind1.main@()
     

     Module Example
        Public Sub Main()
           Dim phrases() As String = { "ocean blue", "concerned citizen", 
                                       "runOnPhrase" }
           For Each phrase In phrases
              Console.WriteLine("Second word is {0}", GetSecondWord(phrase))
           Next                            
       End Sub
       
       Function GetSecondWord(s As String) As String
          Dim pos As Integer = s.IndexOf(" ")
          Return s.Substring(pos).Trim()
       End Function
     End Module
     ' The example displays the following output:
     '       Second word is blue
     '       Second word is citizen
     '       
     '       Unhandled Exception: System.ArgumentOutOfRangeException: StartIndex cannot be less than zero.
     '       Parameter name: startIndex
     '          at System.String.Substring(Int32 startIndex, Int32 length)
     '          at Example.GetSecondWord(String s)
     '          at Example.Main()
     

     Pour éliminer l’exception, validez la valeur retournée par la méthode de recherche de chaîne avant d’appeler la méthode de manipulation de chaîne.

     using System;
     
     public class Example18
     {
        public static void Main()
        {
           String[] phrases = { "ocean blue", "concerned citizen",
                                "runOnPhrase" };
           foreach (var phrase in phrases) {
              string word = GetSecondWord(phrase);
              if (! string.IsNullOrEmpty(word))
                 Console.WriteLine("Second word is {0}", word);
           }
        }
     
        static string GetSecondWord(string s)
        {
           int pos = s.IndexOf(" ");
           if (pos >= 0)
              return s.Substring(pos).Trim();
           else
              return string.Empty;
        }
     }
     // The example displays the following output:
     //       Second word is blue
     //       Second word is citizen
     

     open System
     
     let getSecondWord (s: string) =
         let pos = s.IndexOf " "
         if pos >= 0 then
             s.Substring(pos).Trim()
         else 
             String.Empty
     
     let phrases = [ "ocean blue"; "concerned citizen"; "runOnPhrase" ]
     for phrase in phrases do
         let word = getSecondWord phrase
         if not (String.IsNullOrEmpty word) then
             printfn $"Second word is {word}"
     
     // The example displays the following output:
     //       Second word is blue
     //       Second word is citizen
     

     Module Example
        Public Sub Main()
           Dim phrases() As String = { "ocean blue", "concerned citizen", 
                                       "runOnPhrase" }
           For Each phrase In phrases
              Dim word As String = GetSecondWord(phrase)
              If Not String.IsNullOrEmpty(word) Then _
                 Console.WriteLine("Second word is {0}", word)
           Next                            
        End Sub
       
        Function GetSecondWord(s As String) As String
           Dim pos As Integer = s.IndexOf(" ")
           If pos >= 0
               Return s.Substring(pos).Trim()
           Else
              Return String.Empty
           End If
       End Function
     End Module
     ' The example displays the following output:
     '       Second word is blue
     '       Second word is citizen
     

  3. Vous avez tenté d’extraire une sous-chaîne qui se trouve en dehors de la plage de la chaîne actuelle.

     Les méthodes qui extraient les sous-chaînes nécessitent toutes que vous spécifiiez la position de départ de la sous-chaîne et, pour les sous-chaînes qui ne continuent pas jusqu’à la fin de la chaîne, le nombre de caractères dans la sous-chaîne. Notez qu’il ne s’agit pas de l’index du dernier caractère de la sous-chaîne.

     Une ArgumentOutOfRangeException exception est généralement levée dans ce cas, car vous avez mal calculé le nombre de caractères dans la sous-chaîne. Si vous utilisez une méthode de recherche telle que String.IndexOf pour identifier les positions de début et de fin d’une sous-chaîne :

     • Si le caractère de la position de fin retournée par String.IndexOf doit être inclus dans la sous-chaîne, la position de fin de la sous-chaîne est donnée par la formule

       endIndex - startIndex + 1
       

     • Si le caractère de la position de fin retournée par String.IndexOf doit être exclu de la sous-chaîne, la position de fin de la sous-chaîne est donnée par la formule

       endIndex - startIndex
       

       L’exemple suivant définit une FindWords méthode qui utilise la String.IndexOfAny(Char[], Int32) méthode pour identifier les caractères d’espace et les marques de ponctuation dans une chaîne et retourne un tableau qui contient les mots trouvés dans la chaîne.

       using System;
       using System.Collections.Generic;
       
       public class Example19
       {
          public static void Main()
          {
             string sentence = "This is a simple, short sentence.";
             Console.WriteLine("Words in '{0}':", sentence);
             foreach (var word in FindWords(sentence))
                Console.WriteLine("   '{0}'", word);
          }
       
          static String[] FindWords(string s)
          {
             int start = 0, end = 0;
             Char[] delimiters = { ' ', '.', ',', ';', ':', '(', ')' };
             var words = new List<string>();
       
             while (end >= 0) {
                end = s.IndexOfAny(delimiters, start);
                if (end >= 0) {
                   if (end - start > 0)
                      words.Add(s.Substring(start, end - start));
       
                   start = end + 1;
                }
                else {
                   if (start < s.Length - 1)
                      words.Add(s.Substring(start));
                }
             }
             return words.ToArray();
          }
       }
       // The example displays the following output:
       //       Words in 'This is a simple, short sentence.':
       //          'This'
       //          'is'
       //          'a'
       //          'simple'
       //          'short'
       //          'sentence'
       

       
       let findWords (s: string) =
           let mutable start, end' = 0, 0
           let delimiters = [| ' '; '.'; ','; ';'; ':'; '('; ')' |]
           let words = ResizeArray<string>()
           while end' >= 0 do
               end' <- s.IndexOfAny(delimiters, start)
               if end' >= 0 then
                   if end' - start > 0 then
                       words.Add(s.Substring(start, end' - start))
                   start <- end' + 1
               elif start < s.Length - 1 then
                   words.Add(s.Substring start)
           words.ToArray()
       
       let sentence = "This is a simple, short sentence."
       printfn $"Words in '{sentence}':"
       for word in findWords sentence do
           printfn $"   '{word}'"
       
       // The example displays the following output:
       //       Words in 'This is a simple, short sentence.':
       //          'This'
       //          'is'
       //          'a'
       //          'simple'
       //          'short'
       //          'sentence'
       

       Imports System.Collections.Generic
       
       Module Example
          Public Sub Main()
             Dim sentence As String = "This is a simple, short sentence."
             Console.WriteLine("Words in '{0}':", sentence)
             For Each word In FindWords(sentence)
                Console.WriteLine("   '{0}'", word)
             Next
          End Sub
          
          Function FindWords(s As String) As String()
             Dim start, ending As Integer
             Dim delimiters() As Char = { " "c, "."c, ","c, ";"c, ":"c,
                                          "("c, ")"c }
             Dim words As New List(Of String)()
       
             Do While ending >= 0
                ending = s.IndexOfAny(delimiters, start)
                If ending >= 0
                   If ending - start > 0 Then
                      words.Add(s.Substring(start, ending - start)) 
                   End If
                   start = ending + 1
                Else
                   If start < s.Length - 1 Then
                      words.Add(s.Substring(start))
                   End If      
                End If
             Loop    
             Return words.ToArray()                         
          End Function
       End Module
       ' The example displays the following output:
       '       Words in 'This is a simple, short sentence.':
       '          'This'
       '          'is'
       '          'a'
       '          'simple'
       '          'short'
       '          'sentence'
       

• Vous avez passé un nombre négatif à une méthode avec un argument qui ne nécessite que des nombres positifs et zéro, ou vous avez passé un nombre négatif ou zéro à une méthode avec un argument qui ne nécessite que des nombres positifs.

  Par exemple, la Array.CreateInstance(Type, Int32, Int32, Int32) méthode exige que vous spécifiiez le nombre d’éléments dans chaque dimension d’un tableau à deux dimensions ; les valeurs valides pour chaque dimension peuvent être comprises entre 0 et Int32.MaxValue. Toutefois, étant donné que l’argument de dimension dans l’exemple suivant a une valeur négative, la méthode lève une ArgumentOutOfRangeException exception.

  using System;
  
  public class Example01
  {
      public static void Main()
      {
          int dimension1 = 10;
          int dimension2 = -1;
          try
          {
              Array arr = Array.CreateInstance(typeof(string),
                                               dimension1, dimension2);
          }
          catch (ArgumentOutOfRangeException e)
          {
              if (e.ActualValue != null)
                  Console.WriteLine("{0} is an invalid value for {1}: ", e.ActualValue, e.ParamName);
              Console.WriteLine(e.Message);
          }
      }
  }
  // The example displays the following output:
  //     Non-negative number required.
  //     Parameter name: length2
  

  open System
  
  let dimension1 = 10
  let dimension2 = -1
  try
      let arr = Array.CreateInstance(typeof<string>, dimension1, dimension2)
      printfn "%A" arr
  with 
  | :? ArgumentOutOfRangeException as e ->
      if not (isNull e.ActualValue) then
          printfn $"{e.ActualValue} is an invalid value for {e.ParamName}: "
      printfn $"{e.Message}"
  
  // The example displays the following output:
  //     Non-negative number required. (Parameter 'length2')
  

  Module Example
     Public Sub Main()
        Dim dimension1 As Integer = 10
        Dim dimension2 As Integer = -1
        Try
           Dim arr AS Array = Array.CreateInstance(GetType(String), 
                                                   dimension1, dimension2)
        Catch e As ArgumentOutOfRangeException
           If e.ActualValue IsNot Nothing Then
              Console.WriteLine("{0} is an invalid value for {1}: ", 
                                e.ActualValue, e.ParamName)
           End If                     
           Console.WriteLine(e.Message)
        End Try
     End Sub
  End Module
  ' The example displays the following output:
  '     Non-negative number required.
  '     Parameter name: length2
  

  Pour corriger l’erreur, vérifiez que la valeur de l’argument non valide n’est pas négative. Pour ce faire, fournissez une valeur valide, comme le fait le fragment de code suivant.

  int dimension1 = 10;
  int dimension2 = 10;
  Array arr = Array.CreateInstance(typeof(string),
                                   dimension1, dimension2);
  

  let dimension1 = 10
  let dimension2 = 10
  let arr = Array.CreateInstance(typeof<string>, dimension1, dimension2)
  printfn "%A" arr
  

  Dim dimension1 As Integer = 10
  Dim dimension2 As Integer = 10
  Dim arr As Array = Array.CreateInstance(GetType(String), 
                                          dimension1, dimension2)
  

  Vous pouvez également valider l’entrée et, si elle n’est pas valide, effectuer une action. Le fragment de code suivant affiche un message d’erreur au lieu d’appeler la méthode .

  if (dimension1 < 0 || dimension2 < 0)
  {
      Console.WriteLine("Unable to create the array.");
      Console.WriteLine("Specify non-negative values for the two dimensions.");
  }
  else
  {
      arr = Array.CreateInstance(typeof(string),
                                 dimension1, dimension2);
  }
  

  if dimension1 < 0 || dimension2 < 0 then
      printfn "Unable to create the array."
      printfn "Specify non-negative values for the two dimensions."
  else
      let arr = Array.CreateInstance(typeof<string>, dimension1, dimension2)
      printfn "%A" arr
  

  If dimension1 < 0 OrElse dimension2 < 0 Then
     Console.WriteLine("Unable to create the array.")
     Console.WriteLine("Specify non-negative values for the two dimensions.")
  Else
     arr = Array.CreateInstance(GetType(String), 
                                dimension1, dimension2)   
  End If
  

• Il existe une condition de concurrence dans une application qui est multithread ou dont les tâches s’exécutent de façon asynchrone et qui met à jour un tableau ou une collection.

  L’exemple suivant utilise un List<T> objet pour remplir une collection d’objets Continent . Il lève un si l’exemple tente d’afficher ArgumentOutOfRangeException les sept éléments de la collection avant que la collection soit entièrement remplie.

  using System;
  using System.Collections.Generic;
  using System.Threading;
  
  public class Continent
  {
     public string? Name { get; set; }
     public int Population { get; set; }
     public Decimal Area { get; set; }
  }
  
  public class Example11
  {
     static List<Continent> continents = new List<Continent>();
     static string? s_msg;
  
     public static void Main()
     {
        String[] names = { "Africa", "Antarctica", "Asia",
                           "Australia", "Europe", "North America",
                           "South America" };
        // Populate the list.
        foreach (var name in names) {
           var th = new Thread(PopulateContinents);
           th.Start(name);
        }
        Console.WriteLine(s_msg);
        Console.WriteLine();
  
        // Display the list.
        for (int ctr = 0; ctr < names.Length; ctr++) {
           var continent = continents[ctr];
           Console.WriteLine("{0}: Area: {1}, Population {2}",
                             continent.Name, continent.Population,
                             continent.Area);
        }
     }
  
     private static void PopulateContinents(Object? obj)
     {
        string? name = obj?.ToString();
        s_msg += string.Format("Adding '{0}' to the list.\n", name);
        var continent = new Continent();
        continent.Name = name;
        // Sleep to simulate retrieving remaining data.
        Thread.Sleep(50);
        continents.Add(continent);
     }
  }
  // The example displays output like the following:
  //    Adding //Africa// to the list.
  //    Adding //Antarctica// to the list.
  //    Adding //Asia// to the list.
  //    Adding //Australia// to the list.
  //    Adding //Europe// to the list.
  //    Adding //North America// to the list.
  //    Adding //South America// to the list.
  //
  //
  //
  //    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.ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument argument, ExceptionResource resource)
  //       at Example.Main()
  

  open System.Threading
  
  type Continent =
      { Name: string
        Population: int
        Area: decimal }
  
  let continents = ResizeArray<Continent>()
  let mutable msg = ""
  
  let names = 
      [ "Africa"; "Antarctica"; "Asia"
        "Australia"; "Europe"; "North America"
        "South America" ]
  
  let populateContinents obj = 
      let name = string obj
      msg <- msg + $"Adding '{name}' to the list.\n"
      // Sleep to simulate retrieving data.
      Thread.Sleep 50
      let continent = 
          { Name = name
            Population = 0
            Area = 0M }
      continents.Add continent
        
  // Populate the list.
  for name in names do
      let th = Thread(ParameterizedThreadStart populateContinents)
      th.Start name
        
  printfn $"{msg}\n"
  
  // Display the list.
  for i = 0 to names.Length - 1 do
      let continent = continents[i]
      printfn $"{continent.Name}: Area: {continent.Population}, Population {continent.Area}"
  
  // The example displays output like the following:
  //    Unhandled Exception: System.ArgumentOutOfRangeException: Index was out of range. Must be non-negative and less than the size of the collection. (Parameter 'index')
  //       at System.Collections.Generic.List`1.get_Item(Int32 index)
  //       at <StartupCode$argumentoutofrangeexception>.$Race1.main@()
  

  Imports System.Collections.Generic
  Imports System.Threading
  
  Public Class Continent
     Public Property Name As String
     Public Property Population As Integer
     Public Property Area As Decimal  
  End Class
  
  Module Example
     Dim continents As New List(Of Continent)
     Dim msg As String 
        
     Public Sub Main()
        Dim names() As String = { "Africa", "Antarctica", "Asia", 
                                       "Australia", "Europe", "North America",
                                       "South America" }
        ' Populate the list.
        For Each name In names
           Dim th As New Thread(AddressOf PopulateContinents)
           th.Start(name)
        Next              
        Console.WriteLine(msg)
        Console.WriteLine()
  
        ' Display the list.
        For ctr As Integer = 0 To names.Length - 1
           Dim continent = continents(ctr)
           Console.WriteLine("{0}: Area: {1}, Population {2}", 
                             continent.Name, continent.Population,
                             continent.Area)
        Next
     End Sub
     
     Private Sub PopulateContinents(obj As Object)
        Dim name As String = obj.ToString()
        msg += String.Format("Adding '{0}' to the list.{1}", name, vbCrLf)
        Dim continent As New Continent()
        continent.Name = name
        ' Sleep to simulate retrieving remaining data.
        Thread.Sleep(50)
        continents.Add(continent)
     End Sub
  End Module
  ' The example displays output like the following:
  '    Adding 'Africa' to the list.
  '    Adding 'Antarctica' to the list.
  '    Adding 'Asia' to the list.
  '    Adding 'Australia' to the list.
  '    Adding 'Europe' to the list.
  '    Adding 'North America' to the list.
  '    Adding 'South America' to the list.
  '    
  '    
  '    
  '    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.ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument argument, ExceptionResource resource)
  '       at Example.Main()
  

  Dans ce cas, deux ressources sont accessibles à partir de plusieurs threads :

  • Collection continents. Sa List<T>.Add méthode est appelée à partir de plusieurs threads. En outre, le thread main ou principal suppose que la collection est entièrement remplie avec sept éléments lorsqu’elle itère ses membres.

  • Chaîne msg concaténée à partir de plusieurs threads.

  Pour corriger l’erreur, assurez-vous que l’état partagé est accessible de manière thread-safe, comme suit.

  • Si votre application utilise un tableau ou un objet de collection, envisagez d’utiliser une classe de collection thread-safe, telle que les types dans l’espace System.Collections.Concurrent de noms ou la System.Collections.Immutable version hors bande.

  • Assurez-vous que l’état partagé (c’est-à-dire les ressources accessibles par plusieurs threads) est accessible de manière sécurisée par thread, de sorte qu’un seul thread à la fois dispose d’un accès exclusif aux ressources. Un grand nombre de classes, telles que CountdownEvent, Interlocked, Monitoret Mutex, sont disponibles pour synchroniser l’accès aux ressources. Pour plus d’informations, consultez Threading. En outre, la prise en charge du langage est disponible via l’instruction lock en C# et la construction SyncLock dans Visual Basic.

  L’exemple suivant traite le ArgumentOutOfRangeException et les autres problèmes de l’exemple précédent. Il remplace l’objet List<T> par un ConcurrentBag<T> objet pour garantir que l’accès à la collection est thread-safe, utilise un CountdownEvent objet pour s’assurer que le thread d’application continue uniquement après l’exécution d’autres threads et utilise un verrou pour s’assurer qu’un seul thread peut accéder à la variable à la msg fois.

  using System;
  using System.Collections.Concurrent;
  using System.Threading;
  
  public class ContinentD
  {
     public string? Name { get; set; }
     public int Population { get; set; }
     public Decimal Area { get; set; }
  }
  
  public class Example12
  {
     static ConcurrentBag<ContinentD> ContinentDs = new ConcurrentBag<ContinentD>();
     static CountdownEvent? gate;
     static string msg = string.Empty;
  
     public static void Main()
     {
        String[] names = { "Africa", "Antarctica", "Asia",
                           "Australia", "Europe", "North America",
                           "South America" };
        gate = new CountdownEvent(names.Length);
  
        // Populate the list.
        foreach (var name in names) {
           var th = new Thread(PopulateContinentDs);
           th.Start(name);
        }
  
        // Display the list.
        gate.Wait();
        Console.WriteLine(msg);
        Console.WriteLine();
  
        var arr = ContinentDs.ToArray();
        for (int ctr = 0; ctr < names.Length; ctr++) {
           var ContinentD = arr[ctr];
           Console.WriteLine("{0}: Area: {1}, Population {2}",
                             ContinentD.Name, ContinentD.Population,
                             ContinentD.Area);
        }
     }
  
     private static void PopulateContinentDs(Object? obj)
     {
        string? name = obj?.ToString();
        lock(msg) {
           msg += string.Format("Adding '{0}' to the list.\n", name);
        }
        var ContinentD = new ContinentD();
        ContinentD.Name = name;
        // Sleep to simulate retrieving remaining data.
        Thread.Sleep(25);
        ContinentDs.Add(ContinentD);
        gate?.Signal();
     }
  }
  // The example displays output like the following:
  //       Adding 'Africa' to the list.
  //       Adding 'Antarctica' to the list.
  //       Adding 'Asia' to the list.
  //       Adding 'Australia' to the list.
  //       Adding 'Europe' to the list.
  //       Adding 'North America' to the list.
  //       Adding 'South America' to the list.
  //
  //
  //       Africa: Area: 0, Population 0
  //       Antarctica: Area: 0, Population 0
  //       Asia: Area: 0, Population 0
  //       Australia: Area: 0, Population 0
  //       Europe: Area: 0, Population 0
  //       North America: Area: 0, Population 0
  //       South America: Area: 0, Population 0
  

  open System.Collections.Concurrent
  open System.Threading
  
  type Continent =
      { Name: string
        Population: int
        Area: decimal }
  
  let continents = ConcurrentBag<Continent>();
  let mutable msg = ""
  
  let names = 
      [ "Africa"; "Antarctica"; "Asia"
        "Australia"; "Europe"; "North America"
        "South America" ]
  
  let gate = new CountdownEvent(names.Length)
  
  let populateContinents obj = 
      let name = string obj
      lock msg (fun () -> 
          msg <- msg + $"Adding '{name}' to the list.\n" )
  
      // Sleep to simulate retrieving remaining data.
      let continent = 
          { Name = name
            Population = 0
            Area = 0M }
      Thread.Sleep 25
      continents.Add continent
      gate.Signal() |> ignore
  
  // Populate the list.
  for name in names do
      let th = Thread(ParameterizedThreadStart populateContinents)
      th.Start name
  
  // Display the list.
  gate.Wait();
  printfn $"{msg}\n"
  
  let arr = continents.ToArray();
  for i = 0 to names.Length - 1 do
      let continent = arr[i]
      printfn $"{continent.Name}: Area: {continent.Population}, Population {continent.Area}"
  
  // The example displays output like the following:
  //       Adding 'Africa' to the list.
  //       Adding 'Antarctica' to the list.
  //       Adding 'Asia' to the list.
  //       Adding 'Australia' to the list.
  //       Adding 'Europe' to the list.
  //       Adding 'North America' to the list.
  //       Adding 'South America' to the list.
  //
  //
  //       Africa: Area: 0, Population 0
  //       Antarctica: Area: 0, Population 0
  //       Asia: Area: 0, Population 0
  //       Australia: Area: 0, Population 0
  //       Europe: Area: 0, Population 0
  //       North America: Area: 0, Population 0
  //       South America: Area: 0, Population 0
  

  Imports System.Collections.Concurrent
  Imports System.Threading
  
  Public Class Continent
     Public Property Name As String
     Public Property Population As Integer
     Public Property Area As Decimal  
  End Class
  
  Module Example
     Dim continents As New ConcurrentBag(Of Continent)
     Dim gate As CountdownEvent
     Dim msg As String = String.Empty
        
     Public Sub Main()
        Dim names() As String = { "Africa", "Antarctica", "Asia", 
                                  "Australia", "Europe", "North America",
                                  "South America" }
        gate = new CountdownEvent(names.Length)
        
        ' Populate the list.
        For Each name In names
           Dim th As New Thread(AddressOf PopulateContinents)
           th.Start(name)
        Next              
  
        ' Display the list.
        gate.Wait()
        Console.WriteLine(msg)
        Console.WriteLine()
  
        For ctr As Integer = 0 To names.Length - 1
           Dim continent = continents(ctr)
           Console.WriteLine("{0}: Area: {1}, Population {2}", 
                             continent.Name, continent.Population,
                             continent.Area)
        Next
     End Sub
     
     Private Sub PopulateContinents(obj As Object)
        Dim name As String = obj.ToString()
        SyncLock msg 
           msg += String.Format("Adding '{0}' to the list.{1}", name, vbCrLf)
        End SyncLock
        Dim continent As New Continent()
        continent.Name = name
        ' Sleep to simulate retrieving remaining data.
        Thread.Sleep(25)
        continents.Add(continent)
        gate.Signal()
     End Sub
  End Module
  ' The example displays output like the following:
  '    Adding 'Africa' to the list.
  '    Adding 'Antarctica' to the list.
  '    Adding 'Asia' to the list.
  '    Adding 'Australia' to the list.
  '    Adding 'Europe' to the list.
  '    Adding 'North America' to the list.
  '    Adding 'South America' to the list.
  '    
  '    
  '    Africa: Area: 0, Population 0
  '    Antarctica: Area: 0, Population 0
  '    Asia: Area: 0, Population 0
  '    Australia: Area: 0, Population 0
  '    Europe: Area: 0, Population 0
  '    North America: Area: 0, Population 0
  '    South America: Area: 0, Population 0
  

ArgumentOutOfRangeException utilise le COR_E_ARGUMENTOUTOFRANGE HRESULT, qui a la valeur 0x80131502.

Pour obtenir la liste des valeurs initiales des propriétés d’une instance de ArgumentOutOfRangeException, consultez le ArgumentOutOfRangeException constructeurs.

Constructeurs

Propriétés

Méthodes

Événements

S’applique à

Voir aussi

• Exception