ArgumentOutOfRangeException 类

定义

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

继承

Object

Exception

ArgumentException

ArgumentOutOfRangeException

继承

Object

Exception

SystemException

ArgumentException

ArgumentOutOfRangeException

属性

SerializableAttribute ComVisibleAttribute

实现

ISerializable

示例

下面的示例定义了一个类，以包含有关受邀请的来宾的信息。The following example defines a class to contain information about an invited guest. 如果来宾小于21，则 ArgumentOutOfRangeException 会引发异常。If the guest is younger than 21, an ArgumentOutOfRangeException exception is thrown.

using System;

class Program
{
    static void Main(string[] args)
    {
        try
        {
            Guest guest1 = new Guest("Ben", "Miller", 17);
            Console.WriteLine(guest1.GuestInfo());
        }
        catch (ArgumentOutOfRangeException outOfRange)
        {

            Console.WriteLine("Error: {0}", outOfRange.Message);
        }
    }
}

class Guest
{
    private string FirstName;
    private string LastName;
    private int Age;

    public Guest(string fName, string lName, int age)
    {
        FirstName = fName;
        LastName = lName;
        if (age < 21)
            throw new ArgumentOutOfRangeException("age","All guests must be 21-years-old or older.");
        else
            Age = age;
    }

    public string GuestInfo()
    {
        string gInfo = FirstName + " " + LastName + ", " + Age.ToString();
        return(gInfo);
    }
}

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

注解

ArgumentOutOfRangeException如果调用方法，并且至少有一个传递给方法的参数不是 null ，并且包含的值不是参数所需的值集的成员，则会引发异常。An ArgumentOutOfRangeException exception is thrown when a method is invoked and at least one of the arguments passed to the method is not null and contains an invalid value that is not a member of the set of values expected for the argument. ParamName属性标识无效参数， ActualValue 如果存在值，则属性标识无效值。The ParamName property identifies the invalid argument, and the ActualValue property, if a value is present, identifies the invalid value.

通常是 ArgumentOutOfRangeException 来自开发人员错误的结果。Typically, an ArgumentOutOfRangeException results from developer error. try / catch 如果用户在传递到引发异常的方法之前由方法调用或输入返回参数，则应该先验证参数，然后再将参数传递给方法，而不是在块中处理异常。Instead of handling the exception in a try/catch block, you should eliminate the cause of the exception or, if the argument is returned by a method call or input by the user before being passed to the method that throws the exception, you should validate arguments before passing them to the method.

ArgumentOutOfRangeException 广泛使用：ArgumentOutOfRangeException is used extensively by:

• System.Collections和命名空间中的类 System.IO 。Classes in the System.Collections and System.IO namespaces.

• Array 类。The Array class.

• 类中的字符串操作方法 String 。String manipulation methods in the String class.

ArgumentOutOfRangeException引发异常的条件包括：The conditions in which an ArgumentOutOfRangeException exception is thrown include the following:

• 您正按索引号检索集合的成员，并且索引号无效。You are retrieving the member of a collection by its index number, and the index number is invalid.

  这是异常的最常见原因 ArgumentOutOfRangeException 。This is the most common cause of an ArgumentOutOfRangeException exception. 通常，索引号无效，原因如下：Typically, the index number is invalid for one of four reasons:

  1. 集合没有任何成员，你的代码将假定它具有。The collection has no members, and your code assumes that it does. 下面的示例尝试检索集合中没有元素的第一个元素：The following example attempts to retrieve the first element of a collection that has no elements:

     using System;
     using System.Collections.Generic;
     
     public class Example
     {
        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
     

     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
     

     若要避免此异常，请检查集合的 Count 属性在尝试检索任何成员之前是否大于零，如下面的代码片段所示。To prevent the exception, check whether the collection's Count property is greater than zero before attempting to retrieve any members, as the following code fragment does.

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

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

  2. 在某些情况下，可能会发生异常，因为您尝试使用不存在的索引将成员添加到集合，而不是通过调用此方法存在的方法（如 Add ）。In some cases, the exception may occur because you are attempting to add a member to a collection by using an index that does not exist, rather than by calling the method, such as Add, that exists for this purpose. 下面的示例尝试使用不存在的索引（而不是调用方法），将元素添加到集合中 List<T>.Add 。The following example attempts to add an element to a collection by using a non-existent index rather than calling the List<T>.Add method.

     using System;
     using System.Collections.Generic;
     
     public class Example
     {
        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()
     

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

     下面的代码片段更正此错误：The following code fragment corrects this error:

     var squares = new List<int>();
     for (int ctr = 0; ctr < numbers.Count; ctr++)
        squares.Add((int) Math.Pow(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. 正在尝试检索的项的索引为负。You're attempting to retrieve an item whose index is negative. 出现这种情况的原因通常是：您已经在集合中搜索了某个特定元素的索引，并误假设搜索成功了。This usually occurs because you've searched a collection for the index of a particular element and have erroneously assumed that the search is successful. 在下面的示例中，对方法的调用 List<T>.FindIndex(Predicate<T>) 无法找到等于 "Z" 的字符串，因此返回-1。In the following example, the call to the List<T>.FindIndex(Predicate<T>) method fails to find a string equal to "Z" and so returns -1. 但是，这是无效的索引值。However, this is an invalid index value.

     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
     

     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
     

     若要避免此异常，请在尝试从集合中检索项之前确保返回的索引大于或等于零，以检查搜索是否成功，如以下代码片段所示。To prevent the exception, check that the search is successful by making sure that the returned index is greater than or equal to zero before attempting to retrieve the item from the collection, as the following code fragment does.

     // 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".
     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. 正在尝试检索一个元素，该元素的索引等于集合的属性的值 Count ，如下面的示例所示。You're attempting to retrieve an element whose index is equal to the value of the collection's Count property, as the following example illustrates.

     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" } );
           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
     

     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
     

     由于 .NET 中的集合使用从零开始的索引，因此集合的第一个元素位于索引0处，最后一个元素位于索引 Count -1 处。Because collections in .NET use zero-based indexing, the first element of the collection is at index 0, and the last element is at index Count - 1. 可以通过确保访问索引-1 处的最后一个元素来消除此错误 Count ，如以下代码所示。You can eliminate the error by ensuring that you access the last element at index Count - 1, as the following code does.

     // 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 ctr As Integer = 0 To list.Count - 1 
        Console.WriteLine("Index {0}: {1}", ctr, list(ctr)) 
     Next   
     

• 您正尝试通过调用字符串操作方法来执行字符串操作，并且该字符串中不存在起始索引。You are attempting to perform a string operation by calling a string manipulation method, and the starting index does not exist in the string.

  诸如、、、、、、、或等方法的重载 String.Compare ， String.CompareOrdinal String.IndexOf 这些方法 IndexOfAny String.Insert String.LastIndexOf String.LastIndexOfAny Remove String.Substring 允许你指定操作的起始索引要求索引为字符串内的有效位置。Overloads of methods such as such as String.Compare, String.CompareOrdinal, String.IndexOf, IndexOfAny, String.Insert, String.LastIndexOf, String.LastIndexOfAny, Remove, or String.Substring that allow you to specify the starting index of the operation require that the index be a valid position within the string. 有效索引的范围介于0到 String.Length -1 之间。Valid indexes range from 0 to String.Length - 1.

  此异常有四个常见的原因 ArgumentOutOfRangeException ：There are four common causes of this ArgumentOutOfRangeException exception:

  1. 您正在使用一个空字符串或 String.Empty 。You are working with an empty string, or String.Empty. 由于其 String.Length 属性返回0，因此通过索引对其进行操作的任何尝试都将引发 ArgumentOutOfRangeException 异常。Because its String.Length property returns 0, any attempt to manipulate it by index throws an ArgumentOutOfRangeException exception. 下面的示例定义了一个 GetFirstCharacter 方法，该方法返回字符串的第一个字符。The following example, defines a GetFirstCharacter method that returns the first character of a string. 如果字符串为空，并且传递给该方法的最终字符串为，则该方法将引发 ArgumentOutOfRangeException 异常。If the string is empty, as the final string passed to the method is, the method throws an ArgumentOutOfRangeException exception.

     using System;
     
     public class Example
     {
        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()
     

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

     您可以通过测试字符串是否 String.Length 大于零或通过调用 IsNullOrEmpty 方法来确保字符串不为或空，来消除异常 null 。You can eliminate the exception by testing whether the string's String.Length is greater than zero or by calling the IsNullOrEmpty method to ensure that the string is not null or empty. 下面的代码段执行后者。The following code fragment does the latter. 在这种情况下，如果字符串为 null 或为空，则该 GetFirstCharacter 方法将返回 U + 0000。In this case, if the string is null or empty, the GetFirstCharacter method returns U+0000.

     static char GetFirstCharacter(String s)
     {
        if (String.IsNullOrEmpty(s))
           return '\u0000';
        else
           return 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. 你要根据子字符串在该字符串中的位置来操作字符串，但你未能确定子字符串是否确实找到。You're manipulating a string based on the position of a substring within that string, and you've failed to determine whether the substring was actually found.

     下面的示例提取两个单词短语的第二个单词。The following example extracts the second word of a two-word phrase. ArgumentOutOfRangeException如果短语只包含一个单词，因此不包含嵌入的空格字符，则会引发异常。It throws an ArgumentOutOfRangeException exception if the phrase consists of only one word, and therefore does not contain an embedded space character. 出现这种情况的原因是对方法的调用 String.IndexOf(String) 返回-1 以指示搜索失败，并将此无效值传递到 String.Substring(Int32) 方法。This occurs because the call to the String.IndexOf(String) method returns -1 to indicate that the search failed, and this invalid value is then passed to the String.Substring(Int32) method.

     using System;
     
     public class Example
     {
        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 Example.GetSecondWord(String s)
     //       at Example.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()
     

     若要消除此异常，请先验证字符串搜索方法返回的值，然后再调用字符串操作方法。To eliminate the exception, validate the value returned by the string search method before calling the string manipulation method.

     using System;
     
     public class Example
     {
        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
     

     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. 您尝试提取的子字符串超出了当前字符串的范围。You've attempted to extract a substring that is outside the range of the current string.

     提取子字符串的方法都需要指定子字符串的起始位置和（对于不会继续到字符串末尾的子字符串，子字符串中的字符数）。The methods that extract substrings all require that you specify the starting position of the substring and, for substrings that do not continue to the end of the string, the number of characters in the substring. 请注意，这不是子字符串中最后一个字符的 索引 。Note that this is not the index of the last character in the substring.

     ArgumentOutOfRangeException在这种情况下，通常会引发异常，因为您已错误地计算了子字符串中的字符数。An ArgumentOutOfRangeException exception is typically thrown in this case because you've incorrectly calculated the number of characters in the substring. 如果使用类似的搜索方法 String.IndexOf 标识子字符串的起始位置和结束位置：If you are using a search method like String.IndexOf to identify the starting and ending positions of a substring:

     • 如果由返回的结束位置中的字符将 String.IndexOf 包含在子字符串中，则该公式将为子字符串的结束位置指定If the character in the ending position returned by String.IndexOf is to be included in the substring, the ending position of the substring is given by the formula

       endIndex - startIndex + 1
       

     • 如果将从子字符串中排除由返回的结束位置中的字符，则该 String.IndexOf 公式将提供该子字符串的结束位置。If the character in the ending position returned by String.IndexOf is to be excluded from the substring, the ending position of the substring is given by the formula

       endIndex - startIndex
       

       下面的示例定义了一个 FindWords 方法，该方法使用 String.IndexOfAny(Char[], Int32) 方法标识字符串中的空格字符和标点符号，并返回一个数组，其中包含在字符串中找到的单词。The following example defines a FindWords method that uses the String.IndexOfAny(Char[], Int32) method to identify space characters and punctuation marks in a string and returns an array that contains the words found in the string.

       using System;
       using System.Collections.Generic;
       
       public class Example
       {
          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'
       

       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'
       

• 您已将一个负数传递到了一个方法，该方法的参数只需要正数和零，或者您已将负数或零传递到带有只需要正数的参数的方法。You have passed a negative number to a method with an argument that requires only positive numbers and zero, or you have passed either a negative number or zero to a method with an argument that requires only positive numbers.

  例如， Array.CreateInstance(Type, Int32, Int32, Int32) 方法要求指定二维数组的每个维度中的元素数; 每个维度的有效值范围为0到 Int32.MaxValue 。For example, the Array.CreateInstance(Type, Int32, Int32, Int32) method requires that you specify the number of elements in each dimension of a two-dimensional array; valid values for each dimension can range from 0 to Int32.MaxValue. 但由于下面的示例中的 dimension 参数具有负值，因此该方法将引发 ArgumentOutOfRangeException 异常。But because the dimension argument in the following example has a negative value, the method throws an ArgumentOutOfRangeException exception.

  using System;
  
  public class Example
  {
     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
  

  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
  

  若要更正此错误，请确保无效参数的值为非负数。To correct the error, ensure that the value of the invalid argument is non-negative. 可以通过提供有效的值来执行此操作，如以下代码片段所示。You can do this by providing a valid value, as the following code fragment does.

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

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

  你还可以验证输入，如果无效，则采取一些操作。You can also validate the input and, if it is invalid, take some action. 下面的代码段显示错误消息，而不是调用方法。The following code fragment displays an error message instead of calling the method.

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

• 在多线程应用程序中，或具有异步执行并更新数组或集合的任务的应用中存在争用情况。A race condition exists in an app that is multithreaded or has tasks that execute asynchronously and that updates an array or collection.

  下面的示例使用 List<T> 对象来填充对象的集合 Continent 。The following example uses a List<T> object to populate a collection of Continent objects. ArgumentOutOfRangeException如果该示例在集合完全填充之前尝试显示集合中的七个项，则会引发。It throws an ArgumentOutOfRangeException if the example attempts to display the seven items in the collection before the collection is fully populated.

  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 Example
  {
     static List<Continent> continents = new List<Continent>();
     static String 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(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();
        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()
  

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

  在这种情况下，可从多个线程访问两个资源：In this case, two resources are accessed from multiple threads:

  • continents 集合。The continents collection. List<T>.Add从多个线程调用其方法。Its List<T>.Add method is called from multiple threads. 此外，主线程或主线程假定集合在循环访问其成员时完全填充了7个元素。In addition, the main or primary thread assumes the collection is fully populated with seven elements when it iterates its members.

  • msg从多个线程串联的字符串。The msg string, which is concatenated from multiple threads.

  若要更正此错误，请确保以线程安全的方式访问共享状态，如下所示。To correct the error, ensure that shared state is accessed in a thread-safe way, as follows.

  • 如果你的应用使用数组或集合对象，请考虑使用线程安全集合类，如命名空间中的类型或带外 System.Collections.Concurrent System.Collections.Immutable 版本。if your app uses an array or collection object, consider using a thread-safe collection class, such as the types in the System.Collections.Concurrent namespace or the System.Collections.Immutable out-of-band release.

  • 确保共享状态 (即，多个线程可访问的资源) 可通过线程安全的方式进行访问，以便一次只有一个线程具有对资源的独占访问权限。Ensure that shared state (that is, resources that can be accessed by multiple threads) is accessed in a thread-safe way, so that only one thread at a time has exclusive access to the resources. 许多类，如 CountdownEvent 、、 Interlocked Monitor 和 Mutex ，可用于同步对资源的访问。A large number of classes, such as CountdownEvent, Interlocked, Monitor, and Mutex, are available to synchronize access to resources. 有关详细信息，请参阅 线程处理。For more information, see Threading. 此外，还可通过 c # 中的 lock 语句和 Visual Basic 中的 SyncLock 构造获取语言支持。In addition, language support is available through the lock statement in C# and the SyncLock construct in Visual Basic.

  下面的示例解决了 ArgumentOutOfRangeException 和上一示例中的其他问题。The following example addresses the ArgumentOutOfRangeException and the other issues from the previous example. 它将对象替换为 List<T> ConcurrentBag<T> 对象，以确保对集合的访问是线程安全的，使用 CountdownEvent 对象确保应用程序线程仅在其他线程执行后继续，并使用锁来确保每次只有一个线程可以访问该 msg 变量。It replaces the List<T> object with a ConcurrentBag<T> object to ensure that access to the collection is thread-safe, uses a CountdownEvent object to ensure that the application thread continues only after other threads have executed, and uses a lock to ensure that only one thread can access the msg variable at a time.

  using System;
  using System.Collections.Concurrent;
  using System.Threading;
  
  public class Continent
  {
     public String Name { get; set; }
     public int Population { get; set; }
     public Decimal Area { get; set; }
  }
  
  public class Example
  {
     static ConcurrentBag<Continent> continents = new ConcurrentBag<Continent>();
     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(PopulateContinents);
           th.Start(name);
        }
  
        // Display the list.
        gate.Wait();
        Console.WriteLine(msg);
        Console.WriteLine();
  
        var arr = continents.ToArray();
        for (int ctr = 0; ctr < names.Length; ctr++) {
           var continent = arr[ctr];
           Console.WriteLine("{0}: Area: {1}, Population {2}",
                             continent.Name, continent.Population,
                             continent.Area);
        }
     }
  
     private static void PopulateContinents(Object obj)
     {
        String name = obj.ToString();
        lock(msg) {
           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(25);
        continents.Add(continent);
        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
  

  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 使用 HRESULT COR_E_ARGUMENTOUTOFRANGE，其值为0x80131502。ArgumentOutOfRangeException uses the HRESULT COR_E_ARGUMENTOUTOFRANGE, which has the value 0x80131502.

有关实例的初始属性值的列表ArgumentOutOfRangeException，请参阅ArgumentOutOfRangeException构造函数。For a list of initial property values for an instance of ArgumentOutOfRangeException, see the ArgumentOutOfRangeException constructors.

构造函数

属性

方法

事件

适用于

另请参阅

• Exception