ArgumentOutOfRangeException Klasse

Definition

Die Ausnahme, die ausgelöst wird, wenn der Wert eines Arguments außerhalb des zulässigen Bereichs von Werten liegt, der von der aufgerufenen Methode definiert wird.

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
Vererbung
ArgumentOutOfRangeException
Vererbung
ArgumentOutOfRangeException
Attribute
Implementiert

Beispiele

Im folgenden Beispiel wird eine -Klasse definiert, die Informationen zu einem eingeladenen Gast enthält. Wenn der Gast größer als 21 ist, wird ArgumentOutOfRangeException eine Ausnahme ausgelöst.

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

Hinweise

Eine Ausnahme wird ausgelöst, wenn eine Methode aufgerufen wird und mindestens eines der an die Methode übergebenen Argumente nicht ist und einen ungültigen Wert enthält, der kein Member des für das Argument erwarteten Wertesets ArgumentOutOfRangeException null ist. Die -Eigenschaft identifiziert das ungültige Argument, und die -Eigenschaft, wenn ein Wert vorhanden ParamName ActualValue ist, identifiziert den ungültigen Wert.

In der Regel ergibt sich ArgumentOutOfRangeException ein Entwicklerfehler. Anstatt die Ausnahme in einem -Block zu behandeln, sollten Sie die Ursache der Ausnahme beseitigen. Wenn das Argument durch einen Methodenaufruf oder eine Eingabe durch den Benutzer zurückgegeben wird, bevor es an die Methode übergeben wird, die die Ausnahme auslöst, sollten Sie Argumente überprüfen, bevor Sie sie an die -Methode try / catch übergeben.

ArgumentOutOfRangeException wird häufig verwendet von:

Die Bedingungen, unter denen ArgumentOutOfRangeException eine Ausnahme ausgelöst wird, umfassen Folgendes:

  • Sie abrufen den Member einer Auflistung nach seiner Indexnummer, und die Indexnummer ist ungültig.

    Dies ist die häufigste Ursache einer ArgumentOutOfRangeException Ausnahme. In der Regel ist die Indexnummer aus einem von vier Gründen ungültig:

    1. Die Auflistung verfügt über keine Member, und Ihr Code geht davon aus, dass dies der Grund ist. Im folgenden Beispiel wird versucht, das erste Element einer Auflistung abzurufen, das keine Elemente enthält:

      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
      

      Um die Ausnahme zu verhindern, überprüfen Sie, ob die -Eigenschaft der Auflistung größer als 0 (null) ist, bevor Sie versuchen, Member abzurufen, wie dies im folgenden Count Codefragment der Fall ist.

      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. In einigen Fällen kann die Ausnahme auftreten, weil Sie versuchen, einer Auflistung einen Member hinzuzufügen, indem Sie einen index verwenden, der nicht vorhanden ist, anstatt die -Methode, wie z. B. , auf aufruft, die für diesen Zweck vorhanden Add ist. Im folgenden Beispiel wird versucht, einer Auflistung ein Element hinzuzufügen, indem ein nicht vorhandener Index verwendet wird, anstatt die -Methode List<T>.Add auf aufruft.

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

      Mit dem folgenden Codefragment wird dieser Fehler korrigiert:

      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. Sie versuchen, ein Element abzurufen, dessen Index negativ ist. Dies tritt normalerweise auf, weil Sie eine Sammlung nach dem Index eines bestimmten Elements durchsucht haben und fälschlicherweise angenommen haben, dass die Suche erfolgreich war. Im folgenden Beispiel findet der Aufruf der -Methode keine Zeichenfolge, die "Z" entspricht, List<T>.FindIndex(Predicate<T>) und gibt daher -1 zurück. Dies ist jedoch ein ungültiger Indexwert.

      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
      

      Um die Ausnahme zu verhindern, überprüfen Sie, ob die Suche erfolgreich ist, indem Sie sicherstellen, dass der zurückgegebene Index größer oder gleich 0 (null) ist, bevor Sie versuchen, das Element aus der Auflistung abzurufen, wie im folgenden Codefragment.

      // 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. Sie versuchen, ein Element abzurufen, dessen Index gleich dem Wert der -Eigenschaft der Auflistung ist, wie im Count folgenden Beispiel veranschaulicht.

      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
      

      Da Sammlungen in .NET die nullbasierte Indizierung verwenden, befindet sich das erste Element der Auflistung bei Index 0, und das letzte Element befindet sich am Index Count 1. Sie können den Fehler beseitigen, indem Sie sicherstellen, dass Sie wie im folgenden Code auf das letzte Element am Index Count 1 zugreifen.

      // 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
      
  • Sie versuchen, einen Zeichenfolgenvorgang durch Aufrufen einer Zeichenfolgenbearbeitungsmethode durchzuführen, und der Startindex ist in der Zeichenfolge nicht vorhanden.

    Überladungen von Methoden wie , , , , , , , , oder , mit denen Sie den Startindex des Vorgangs angeben können, erfordern, dass der Index eine gültige Position innerhalb der Zeichenfolge String.Compare String.CompareOrdinal String.IndexOf IndexOfAny String.Insert String.LastIndexOf String.LastIndexOfAny Remove String.Substring ist. Gültige Indizes liegen zwischen 0 und String.Length 1.

    Es gibt vier häufige Ursachen für diese ArgumentOutOfRangeException Ausnahme:

    1. Sie arbeiten mit einer leeren Zeichenfolge oder String.Empty . Da die -Eigenschaft 0 zurückgibt, löst jeder Versuch, sie durch den Index zu String.Length bearbeiten, eine Ausnahme ArgumentOutOfRangeException aus. Im folgenden Beispiel wird eine Methode GetFirstCharacter definiert, die das erste Zeichen einer Zeichenfolge zurückgibt. Wenn die Zeichenfolge leer ist, wie die letzte Zeichenfolge, die an die Methode übergeben wird, löst die Methode eine Ausnahme ArgumentOutOfRangeException aus.

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

      Sie können die Ausnahme beseitigen, indem Sie testen, ob größer als 0 (null) der Zeichenfolge ist, oder indem Sie die -Methode aufrufen, um sicherzustellen, dass die Zeichenfolge String.Length IsNullOrEmpty nicht oder leer null ist. Das folgende Codefragment führt letzteres aus. Wenn die Zeichenfolge in diesem Fall oder null leer ist, gibt GetFirstCharacter die Methode U+0000 zurück.

      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. Sie bearbeiten eine Zeichenfolge basierend auf der Position einer Teilzeichenfolge innerhalb dieser Zeichenfolge, und Sie haben nicht ermittelt, ob die Teilzeichenfolge tatsächlich gefunden wurde.

      Im folgenden Beispiel wird das zweite Wort eines zweiwortbasierten Ausdrucks extrahiert. Sie löst eine Ausnahme aus, wenn der Ausdruck nur aus einem Wort besteht und daher kein eingebettetes ArgumentOutOfRangeException Leerzeichen enthält. Dies tritt auf, weil der Aufruf der -Methode -1 zurückgibt, um anzugeben, dass die Suche fehlgeschlagen ist, und dieser ungültige Wert dann an die String.IndexOf(String) -Methode übergeben String.Substring(Int32) wird.

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

      Um die Ausnahme zu beseitigen, überprüfen Sie den von der Zeichenfolgensuchmethode zurückgegebenen Wert, bevor Sie die Zeichenfolgenbearbeitungsmethode aufrufen.

      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. Sie haben versucht, eine Teilzeichenfolge zu extrahieren, die außerhalb des Bereichs der aktuellen Zeichenfolge liegt.

      Die Methoden, die Teilzeichenfolgen extrahieren, erfordern, dass Sie die Anfangsposition der Teilzeichenfolge und für Teilzeichenfolgen, die nicht bis zum Ende der Zeichenfolge fortgesetzt werden, die Anzahl der Zeichen in der Teilzeichenfolge angeben. Beachten Sie, dass dies nicht der Index des letzten Zeichens in der Teilzeichenfolge ist.

      In diesem Fall wird in der Regel eine Ausnahme ausgelöst, da Sie die Anzahl der Zeichen in der ArgumentOutOfRangeException Teilzeichenfolge falsch berechnet haben. Wenn Sie eine Suchmethode wie verwenden, um die Anfangs- und String.IndexOf Endpositionen einer Teilzeichenfolge zu identifizieren:

      • Wenn das Zeichen an der von zurückgegebenen Endposition in die Teilzeichenfolge eingeschlossen werden soll, wird die Endposition der Teilzeichenfolge von der String.IndexOf Formel angegeben.

        endIndex - startIndex + 1
        
      • Wenn das Zeichen an der von zurückgegebenen Endposition aus der Teilzeichenfolge ausgeschlossen werden soll, wird die Endposition der Teilzeichenfolge von der String.IndexOf Formel angegeben.

        endIndex - startIndex
        

        Im folgenden Beispiel wird eine Methode definiert, die die -Methode verwendet, um Leerzeichen und Interpunktionszeichen in einer Zeichenfolge zu identifizieren, und gibt ein Array zurück, das die in der Zeichenfolge gefundenen FindWords String.IndexOfAny(Char[], Int32) Wörter enthält.

        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'
        
  • Sie haben eine negative Zahl an eine Methode mit einem Argument übergeben, das nur positive Zahlen und 0 (null) erfordert, oder Sie haben entweder eine negative Zahl oder 0 (null) an eine Methode mit einem Argument übergeben, das nur positive Zahlen erfordert.

    Beispielsweise erfordert die -Methode, dass Sie die Anzahl der Elemente in jeder Dimension eines zweidimensionalen Arrays angeben. Gültige Werte für jede Dimension können zwischen 0 und Array.CreateInstance(Type, Int32, Int32, Int32) Int32.MaxValue liegen. Da das Dimensionsargument im folgenden Beispiel jedoch über einen negativen Wert verfügt, löst die -Methode eine Ausnahme ArgumentOutOfRangeException aus.

    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
    

    Stellen Sie sicher, dass der Wert des ungültigen Arguments nicht negativ ist, um den Fehler zu beheben. Hierzu können Sie einen gültigen Wert wie im folgenden Codefragment bereitstellen.

    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)
    

    Sie können auch die Eingabe überprüfen und, falls sie ungültig ist, eine Aktion ergreifen. Das folgende Codefragment zeigt eine Fehlermeldung an, anstatt die -Methode auf aufruft.

    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
    
  • Eine Racebedingung ist in einer App vorhanden, die multithreaded ist oder Über Tasks verfügt, die asynchron ausgeführt werden und ein Array oder eine Auflistung aktualisieren.

    Im folgenden Beispiel wird ein List<T> -Objekt verwendet, um eine Auflistung von -Objekten zu Continent füllen. Sie löst eine aus, wenn im Beispiel versucht wird, die sieben Elemente in der Auflistung anzuzeigen, ArgumentOutOfRangeException bevor die Auflistung vollständig aufgefüllt wird.

    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 diesem Fall wird über mehrere Threads auf zwei Ressourcen zugegriffen:

    • Die continents-Auflistung. Die List<T>.Add -Methode wird von mehreren Threads aufgerufen. Darüber hinaus geht der Hauptthread oder primäre Thread davon aus, dass die Auflistung vollständig mit sieben Elementen aufgefüllt wird, wenn sie ihre Member durch iteriert.

    • Die msg Zeichenfolge, die aus mehreren Threads verkettet ist.

    Um den Fehler zu beheben, stellen Sie sicher, dass auf den freigegebenen Zustand wie folgt threadsicher zugegriffen wird.

    • Wenn Ihre App ein Array oder Sammlungsobjekt verwendet, sollten Sie eine threadsichere Auflistungsklasse verwenden, z. B. die Typen im Namespace oder das System.Collections.Concurrent System.Collections.Immutable Out-of-Band-Release.

    • Stellen Sie sicher, dass auf den freigegebenen Zustand (d. h. ressourcen, auf die von mehreren Threads zugegriffen werden kann) threadsicher zugegriffen wird, sodass nur ein Thread gleichzeitig exklusiven Zugriff auf die Ressourcen hat. Eine große Anzahl von Klassen, z. B. CountdownEvent , , und , sind Interlocked Monitor Mutex verfügbar, um den Zugriff auf Ressourcen zu synchronisieren. Weitere Informationen finden Sie unter Threading. Darüber hinaus ist Sprachunterstützung über die lock-Anweisung in C# und das SyncLock-Konstrukt in Visual Basic.

    Im folgenden Beispiel werden die ArgumentOutOfRangeException und die anderen Probleme aus dem vorherigen Beispiel behandelt. Er ersetzt das -Objekt durch ein -Objekt, um sicherzustellen, dass der Zugriff auf die Auflistung threadsicher ist, verwendet ein -Objekt, um sicherzustellen, dass der Anwendungsthread erst fortgesetzt wird, nachdem andere Threads ausgeführt wurden, und verwendet eine Sperre, um sicherzustellen, dass nur ein Thread gleichzeitig auf die Variable zugreifen List<T> ConcurrentBag<T> CountdownEvent msg kann.

    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 verwendet die HRESULT-COR_E_ARGUMENTOUTOFRANGE, die den Wert 0x80131502.

Eine Liste der anfänglichen Eigenschaftswerte für eine Instanz von ArgumentOutOfRangeException, finden Sie unter den ArgumentOutOfRangeException Konstruktoren.

Konstruktoren

ArgumentOutOfRangeException()

Initialisiert eine neue Instanz der ArgumentOutOfRangeException-Klasse.

ArgumentOutOfRangeException(SerializationInfo, StreamingContext)

Initialisiert eine neue Instanz der ArgumentOutOfRangeException-Klasse mit serialisierten Daten.

ArgumentOutOfRangeException(String)

Initialisiert eine neue Instanz der ArgumentOutOfRangeException-Klasse mit dem Namen des Parameters, der diese Ausnahme auslöst.

ArgumentOutOfRangeException(String, Exception)

Initialisiert eine neue Instanz der ArgumentOutOfRangeException-Klasse mit einer angegebenen Fehlermeldung und der Ausnahme, die diese Ausnahme ausgelöst hat.

ArgumentOutOfRangeException(String, Object, String)

Initialisiert eine neue Instanz der ArgumentOutOfRangeException-Klasse mit einer angegebenen Fehlermeldung, dem Namen des Parameters und dem Wert des Arguments und einer angegebenen Fehlermeldung.

ArgumentOutOfRangeException(String, String)

Initialisiert eine neue Instanz der ArgumentOutOfRangeException-Klasse mit dem Namen des Parameters, der die Ausnahme auslöst und einer angegebenen Fehlermeldung.

Eigenschaften

ActualValue

Ruft den Argumentwert ab, der die Ausnahme auslöst.

Data

Ruft eine Auflistung von Schlüssel-Wert-Paaren ab, die zusätzliche benutzerdefinierte Informationen zur Ausnahme bereitstellen.

(Geerbt von Exception)
HelpLink

Ruft einen Link zur Hilfedatei ab, die dieser Ausnahme zugeordnet ist, oder legt einen Link fest.

(Geerbt von Exception)
HResult

Ruft HRESULT ab oder legt HRESULT fest. Dies ist ein codierter Wert, der einer bestimmten Ausnahme zugeordnet ist.

(Geerbt von Exception)
InnerException

Ruft die Exception-Instanz ab, die die aktuelle Ausnahme verursacht hat.

(Geerbt von Exception)
Message

Ruft die Fehlermeldung und die Zeichenfolgendarstellung des ungültigen Argumentwerts oder nur die Fehlermeldung ab, wenn der Argumentwert Null ist.

ParamName

Ruft den Namen des Parameters ab, der diese Ausnahme auslöst.

(Geerbt von ArgumentException)
Source

Gibt den Namen der Anwendung oder des Objekts zurück, die bzw. das den Fehler verursacht hat, oder legt diesen fest.

(Geerbt von Exception)
StackTrace

Ruft eine Zeichenfolgendarstellung der unmittelbaren Frames in der Aufrufliste ab.

(Geerbt von Exception)
TargetSite

Ruft die Methode ab, die die aktuelle Ausnahme auslöst.

(Geerbt von Exception)

Methoden

Equals(Object)

Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist.

(Geerbt von Object)
GetBaseException()

Gibt beim Überschreiben in einer abgeleiteten Klasse eine Exception zurück, die die Grundursache für eine oder mehrere nachfolgende Ausnahmen ist.

(Geerbt von Exception)
GetHashCode()

Fungiert als Standardhashfunktion.

(Geerbt von Object)
GetObjectData(SerializationInfo, StreamingContext)

Legt das SerializationInfo-Objekt mit dem ungültigen Argumentwert und zusätzlichen Informationen über die Ausnahme fest.

GetObjectData(SerializationInfo, StreamingContext)

Legt das SerializationInfo-Objekt mit dem Parameternamen und zusätzlichen Informationen zur Ausnahme fest.

(Geerbt von ArgumentException)
GetType()

Ruft den Laufzeittyp der aktuellen Instanz ab.

(Geerbt von Exception)
MemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.

(Geerbt von Object)
ToString()

Erstellt eine Zeichenfolgendarstellung der aktuellen Ausnahme und gibt diese zurück.

(Geerbt von Exception)

Ereignisse

SerializeObjectState
Veraltet.

Tritt auf, wenn eine Ausnahme serialisiert wird, um ein Ausnahmezustandsobjekt mit serialisierten Daten über die Ausnahme zu erstellen.

(Geerbt von Exception)

Gilt für

Siehe auch