ArgumentOutOfRangeException ArgumentOutOfRangeException ArgumentOutOfRangeException ArgumentOutOfRangeException Class

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.The exception that is thrown when the value of an argument is outside the allowable range of values as defined by the invoked method.

public ref class ArgumentOutOfRangeException : ArgumentException
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public class ArgumentOutOfRangeException : ArgumentException
type ArgumentOutOfRangeException = class
    inherit ArgumentException
    interface ISerializable
Public Class ArgumentOutOfRangeException
Inherits ArgumentException
Vererbung
Attribute
Implementiert

Beispiele

Das folgende Beispiel definiert eine Klasse, um Informationen über einen eingeladenen Gast enthalten.The following example defines a class to contain information about an invited guest. Wenn der Gast jünger als 21, ist ein ArgumentOutOfRangeException Ausnahme ausgelöst.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

Hinweise

Ein ArgumentOutOfRangeException -Ausnahme ausgelöst, wenn eine Methode aufgerufen wird und mindestens eines der Argumente an die Methode übergebene nicht null und enthält einen ungültigen Wert, der nicht Mitglied der Gruppe von Werten, die für das Argument erwartet ist.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. Die ParamName identifiziert das Argument ist ungültige, und die ActualValue -Eigenschaft, wenn ein Wert vorhanden ist, ist den ungültigen Wert identifiziert.The ParamName property identifies the invalid argument, and the ActualValue property, if a value is present, identifies the invalid value.

In der Regel eine ArgumentOutOfRangeException ergibt, wenn Entwicklerfehler.Typically, an ArgumentOutOfRangeException results from developer error. Statt die Ausnahme in einem try / catch blockieren, sollten Sie die Ursache der Ausnahme entfernen oder, wenn das Argument durch einen Methodenaufruf zurückgegeben wird, oder vom Benutzer eingegebene, bevor Sie an die Methode übergeben werden, die löst die Ausnahme aus , Sie sollten die Argumente überprüfen, bevor sie an die Methode übergeben.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 von wird häufig verwendet werden:ArgumentOutOfRangeException is used extensively by:

Die Bedingungen in der ein ArgumentOutOfRangeException ausgelöster Ausnahme umfassen Folgendes:The conditions in which an ArgumentOutOfRangeException exception is thrown include the following:

Rufen Sie die Member einer Auflistung nach der Indexnummer aus, und die Indexnummer ist ungültig.You are retrieving the member of a collection by its index number, and the index number is invalid.
Dies ist die häufigste Ursache für eine ArgumentOutOfRangeException Ausnahme.This is the most common cause of an ArgumentOutOfRangeException exception. In der Regel ist die Indexnummer für eine der drei Gründe ungültig:Typically, the index number is invalid for one of three reasons:

  • Die Sammlung keine Mitglieder hat, und Ihr Code wird davon ausgegangen, dass dies der Fall ist.The collection has no members, and your code assumes that it does. Im folgenden Beispiel wird versucht, die das erste Element einer Auflistung abrufen, die keine Elemente enthält: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
    

    Um die Ausnahme zu verhindern, überprüfen Sie, ob der Auflistung Count -Eigenschaft ist größer als 0 (null), bevor Sie versuchen, die alle Elemente abrufen, wie das folgende Codefragment.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
    

    In einigen Fällen kann auftreten, wenn Sie versuchen, ein Mitglied einer Sammlung hinzufügen, mit einem Index, der nicht vorhanden ist und nicht durch Aufrufen der Methode, wie z. B. Add, zu diesem Zweck vorhanden ist.In some cases, this 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. Im folgenden Beispiel wird versucht, ein Element einer Auflistung hinzufügen, indem Sie einen nicht vorhandenen Index verwenden, anstatt aufzurufen der List<T>.Add Methode.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()
    

    Im folgenden Codefragment wird dieser Fehler korrigiert: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
    
  • Sie haben versucht, ein Element abgerufen werden, dessen Index negativ ist.You're attempting to retrieve an item whose index is negative. Dieser Fehler tritt gewöhnlich auf, da Sie eine Sammlung für den Index eines bestimmten Elements durchsucht haben, und Sie fälschlicherweise davon ausgegangen haben, dass die Suche erfolgreich ist.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. Im folgenden Beispiel der Aufruf der List<T>.FindIndex(Predicate<T>) Methode fehlschlägt, finden Sie eine Zeichenfolge, die gleich "Z", und dies gibt-1 zurück.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. Dies ist jedoch in einem ungültigen Indexwert.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
    

    Um die Ausnahme zu verhindern, überprüfen Sie, dass die Suche erfolgreich ist, indem Sie sicherstellen, dass der zurückgegebene Index größer als ist oder gleich 0 (null), bevor Sie versuchen, das Element aus der Auflistung abgerufen werden soll, wie des folgenden Codes Fragment der Fall ist.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
    
  • Sie versuchen, ein Element abrufen, deren Index gleich dem Wert des der Auflistung ist Count -Eigenschaft, wie im folgenden Beispiel illustriert.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
    

    Da Auflistungen in .NET Framework nullbasierte Indizierung verwenden, das erste Element der Auflistung bei Index 0 ist und das letzte Element am Index ist Count - 1.Because collections in the .NET Framework use zero-based indexing, the first element of the collection is at index 0, and the last element is at index Count - 1. Sie können den Fehler vermeiden, indem Sie sicherstellen, dass Sie Zugriff auf das letzte Element am Index Count - 1, wie im folgende Code.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   
    

Sie versuchen, eine Zeichenfolgenoperation auszuführen, indem eine String Manipulation-Methode, und der Startindex ist nicht vorhanden, in der Zeichenfolge.You are attempting to perform a string operation by calling a string manipulation method, and the starting index does not exist in the string.
Überladungen der Methoden, wie z. B. String.Compare, String.CompareOrdinal, String.IndexOf, IndexOfAny, String.Insert, String.LastIndexOf, String.LastIndexOfAny, Remove, oder String.Substring , mit denen Sie den Startindex an das Betrieb erforderlich, dass der Index eine gültige Position innerhalb der Zeichenfolge sein.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. Gültige Indizes liegen zwischen 0 und String.Length - 1.Valid indexes range from 0 to String.Length - 1.

Es gibt vier häufige Ursachen dieses ArgumentOutOfRangeException Ausnahme:There are four common causes of this ArgumentOutOfRangeException exception:

  • Arbeiten Sie mit der eine leere Zeichenfolge oder String.Empty.You are working with an empty string, or String.Empty. Da die String.Length Eigenschaft gibt 0 zurück, jeder Versuch, die vom Index löst bearbeitet ein ArgumentOutOfRangeException Ausnahme.Because its String.Length property returns 0, any attempt to manipulate it by index throws an ArgumentOutOfRangeException exception. Das folgende Beispiel definiert eine GetFirstCharacter Methode, die das erste Zeichen einer Zeichenfolge zurückgibt.The following example, defines a GetFirstCharacter method that returns the first character of a string. Wenn die Zeichenfolge leer ist, wie die endgültige Zeichenfolge, die an die Methode ist, löst die Methode eine ArgumentOutOfRangeException Ausnahme.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()
    

    Vermeiden Sie die Ausnahme, indem Sie testen, ob der Zeichenfolge String.Length ist größer als 0 (null) oder durch Aufrufen der IsNullOrEmpty Methode, um sicherzustellen, dass die Zeichenfolge nicht null oder leer sein.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. Im folgenden Codefragment wird die zweite.The following code fragment does the latter. In diesem Fall, wenn die Zeichenfolge null oder leer ist, die GetFirstCharacter Methodenrückgabe-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
    
  • Sie können eine Zeichenfolge, die auf Grundlage der Position einer Teilzeichenfolge innerhalb dieser Zeichenfolge bearbeiten, und Sie durchgeführt haben, zu bestimmen, ob die Teilzeichenfolge tatsächlich gefunden wurde.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.

    Das folgende Beispiel extrahiert den zweite Wort oder einen Ausdruck für die zwei Wörtern.The following example extracts the second word of a two-word phrase. Löst ein ArgumentOutOfRangeException -Ausnahme aus, wenn der Ausdruck besteht nur aus einem Wort aus, und daher kein eingebettetes Leerzeichen.It throws an ArgumentOutOfRangeException exception if the phrase consists of only one word, and therefore does not contain an embedded space character. Dies geschieht, weil der Aufruf der String.IndexOf(String) Methode gibt-1 zurück, um anzugeben, dass Fehler bei der Suche, und der ungültige Wert wird dann an die String.Substring(Int32) Methode.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()
    

    Überprüfen Sie zur Beseitigung dieser Ausnahme, den Wert, der durch die Zeichenfolge Search-Methode zurückgegeben werden, bevor Sie die Zeichenfolge Manipulation-Methode aufrufen.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
    

-

Sie haben versucht, eine Teilzeichenfolge extrahiert, die außerhalb des Bereichs der aktuellen Zeichenfolge ist.You've attempted to extract a substring that is outside the range of the current string.
Die Methoden, die Teilzeichenfolgen zu extrahieren, die alle erfordern, dass Sie die Anfangsposition der Teilzeichenfolge und für Teilzeichenfolgen, die nicht an das Ende der Zeichenfolge, die Anzahl der Zeichen der Teilzeichenfolge mehr angeben.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. Beachten Sie, dass dies nicht der Index des letzten Zeichens der Teilzeichenfolge.Note that this is not the index of the last character in the substring.

Ein ArgumentOutOfRangeException Ausnahme wird normalerweise in diesem Fall ausgelöst, da Sie die Anzahl der Zeichen der Teilzeichenfolge falsch berechnet haben.An ArgumentOutOfRangeException exception is typically thrown in this case because you've incorrectly calculated the number of characters in the substring. Wenn Sie eine Suchmethode wie verwenden String.IndexOf die Start- und Endposition einer Teilzeichenfolge zu identifizieren:If you are using a search method like String.IndexOf to identify the starting and ending positions of a substring:

  • Wenn das Zeichen in die Endposition von zurückgegeben String.IndexOf in der Teilzeichenfolge, enthalten sein soll die Endposition der die Teilzeichenfolge wird angegeben, durch die FormelIf 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  
    
  • Wenn das Zeichen in die Endposition von zurückgegeben String.IndexOf besteht darin, die Teilzeichenfolge, ausgeschlossen werden soll die Endposition der die Teilzeichenfolge wird angegeben, durch die FormelIf 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   
    

Das folgende Beispiel definiert eine FindWords Methode, verwendet der String.IndexOfAny(Char[], Int32) Methode zur Identifizierung von Leerzeichen und Interpunktionszeichen markiert, die in einer Zeichenfolge und gibt ein Array, das die Wörter finden Sie in der Zeichenfolge enthält.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++;
         }
         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 übergeben, auf eine Methode mit einem Argument, die nur positive Zahlen und 0 (null) erforderlich sind, oder Sie haben übergeben, entweder eine negative Zahl oder 0 (null) an eine Methode mit einem Argument, die nur positive Zahlen erforderlich sind.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.
Z. B. die Array.CreateInstance(Type, Int32, Int32, Int32) Methode erfordert, dass Sie die Anzahl der Elemente in jeder Dimension eines zweidimensionalen Arrays angeben; die gültigen Werte für jede Dimension liegen im Bereich von 0 bis 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. Aber da das Dimensionsargument im folgenden Beispiel einen negativen Wert hat, löst die Methode eine ArgumentOutOfRangeException Ausnahme.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

Stellen Sie sicher, dass der Wert des ungültigen Arguments nicht negativ ist, um den Fehler zu beheben.To correct the error, ensure that the value of the invalid argument is non-negative. Sie können dazu einen gültigen Wert, wie das folgende Codefragment.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)   

Sie können auch Überprüfung der Eingabe- und, wenn er ungültig ist, wird eine bestimmte Aktion.You can also validate the input and, if it is invalid, take some action. Das folgende Codefragment zeigt eine Fehlermeldung angezeigt, statt die Methode an.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

In einer app, die mehreren Threads oder Aufgaben, die asynchron ausgeführt und ein Array oder eine Auflistung, die aktualisiert, wurde, ist eine Racebedingung vorhanden.A race condition exists in an app that is multithreaded or has tasks that execute asynchronously and that updates an array or collection.
Im folgenden Beispiel wird eine List<T> Objekt, das eine Auflistung von aufzufüllen Continent Objekte.The following example uses a List<T> object to populate a collection of Continent objects. Löst ein ArgumentOutOfRangeException -Ausnahme aus, wenn das Beispiel versucht, die sieben Elemente in der Auflistung angezeigt wird, bevor die Auflistung vollständig gefüllt ist.It throws an ArgumentOutOfRangeException exception 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 diesem Fall werden zwei Ressourcen von mehreren Threads zugegriffen werden:In this case, two resources are accessed from multiple threads:

  • Die continents-Auflistung.The continents collection. Die List<T>.Add Methode wird von mehreren Threads aufgerufen.Its List<T>.Add method is called from multiple threads. Der Haupt- oder primäre Thread wird außerdem davon ausgegangen, dass die Auflistung mit sieben Elementen vollständig gefüllt ist, wenn sie ihre Mitglieder durchläuft.In addition, the main or primary thread assumes the collection is fully populated with seven elements when it iterates its members.

  • Die msg Zeichenfolge, die von mehreren Threads verkettet wird.The msg string, which is concatenated from multiple threads.

Stellen Sie sicher, dass gemeinsam genutzten Zustands wie folgt auf threadsichere Weise zugegriffen wird, um den Fehler zu beheben.To correct the error, ensure that shared state is accessed in a thread-safe way, as follows.

  • Wenn Ihre app ein Array oder einer Auflistung-Objekt verwendet wird, erwägen Sie eine threadsichere Auflistungsklasse, z. B. die Typen in der System.Collections.Concurrent Namespace oder die System.Collections.Immutable Out-of-Band-Version.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.

  • Stellen Sie sicher, dass Freigabezustand (d. h. Ressourcen, die von mehreren Threads zugegriffen werden kann) auf threadsichere Weise zugegriffen wird, damit jeweils nur ein Thread exklusiven Zugriff auf die Ressourcen verfügt.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. Eine große Anzahl von Klassen, z. B. CountdownEvent, Interlocked, Monitor, und Mutex, zum Synchronisieren des Zugriffs auf Ressourcen verfügbar sind.A large number of classes, such as CountdownEvent, Interlocked, Monitor, and Mutex, are available to synchronize access to resources. Weitere Informationen finden Sie unter Threading.For more information, see Threading. Darüber hinaus Language Support steht über den Sperre -Anweisung in c# und die SyncLock in Visual Basic erstellen.In addition, language support is available through the lock statement in C# and the SyncLock construct in Visual Basic.

Das folgende Beispiel-Adressen der ArgumentOutOfRangeException Ausnahme und die andere Probleme aus dem vorherigen Beispiel.The following example addresses the ArgumentOutOfRangeException exception and the other issues from the previous example. Er ersetzt die List<T> Objekt mit einer ConcurrentBag<T> Objekt, um sicherzustellen, dass der Zugriff auf die Auflistung threadsicher ist, verwendet eine CountdownEvent Objekt, um sicherzustellen, dass dem Thread der Anwendung fortgesetzt werden, nachdem andere Threads ausgeführt haben und eine Sperre verwendet, um sicherzustellen, dass nur ein Thread zugreifen, kann die msg Variablen zu einem Zeitpunkt.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 verwendet das HRESULT COR_E_ARGUMENTOUTOFRANGE mit dem Wert 0 x 80131502.ArgumentOutOfRangeException uses the HRESULT COR_E_ARGUMENTOUTOFRANGE, which has the value 0x80131502.

Eine Liste der anfänglichen Eigenschaftswerte für eine Instanz von ArgumentOutOfRangeException, finden Sie unter den ArgumentOutOfRangeException Konstruktoren.For a list of initial property values for an instance of ArgumentOutOfRangeException, see the ArgumentOutOfRangeException constructors.

Konstruktoren

ArgumentOutOfRangeException() ArgumentOutOfRangeException() ArgumentOutOfRangeException() ArgumentOutOfRangeException()

Initialisiert eine neue Instanz der ArgumentOutOfRangeException-Klasse.Initializes a new instance of the ArgumentOutOfRangeException class.

ArgumentOutOfRangeException(SerializationInfo, StreamingContext) ArgumentOutOfRangeException(SerializationInfo, StreamingContext) ArgumentOutOfRangeException(SerializationInfo, StreamingContext) ArgumentOutOfRangeException(SerializationInfo, StreamingContext)

Initialisiert eine neue Instanz der ArgumentOutOfRangeException-Klasse mit serialisierten Daten.Initializes a new instance of the ArgumentOutOfRangeException class with serialized data.

ArgumentOutOfRangeException(String) ArgumentOutOfRangeException(String) ArgumentOutOfRangeException(String) ArgumentOutOfRangeException(String)

Initialisiert eine neue Instanz der ArgumentOutOfRangeException-Klasse mit dem Namen des Parameters, der diese Ausnahme auslöst.Initializes a new instance of the ArgumentOutOfRangeException class with the name of the parameter that causes this exception.

ArgumentOutOfRangeException(String, Exception) ArgumentOutOfRangeException(String, Exception) ArgumentOutOfRangeException(String, Exception) ArgumentOutOfRangeException(String, Exception)

Initialisiert eine neue Instanz der ArgumentOutOfRangeException-Klasse mit einer angegebenen Fehlermeldung und der Ausnahme, die diese Ausnahme ausgelöst hat.Initializes a new instance of the ArgumentOutOfRangeException class with a specified error message and the exception that is the cause of this exception.

ArgumentOutOfRangeException(String, Object, String) ArgumentOutOfRangeException(String, Object, String) ArgumentOutOfRangeException(String, Object, String) 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.Initializes a new instance of the ArgumentOutOfRangeException class with the parameter name, the value of the argument, and a specified error message.

ArgumentOutOfRangeException(String, String) ArgumentOutOfRangeException(String, String) ArgumentOutOfRangeException(String, String) ArgumentOutOfRangeException(String, String)

Initialisiert eine neue Instanz der ArgumentOutOfRangeException-Klasse mit dem Namen des Parameters, der die Ausnahme auslöst und einer angegebenen Fehlermeldung.Initializes a new instance of the ArgumentOutOfRangeException class with the name of the parameter that causes this exception and a specified error message.

Eigenschaften

ActualValue ActualValue ActualValue ActualValue

Ruft den Argumentwert ab, der die Ausnahme auslöst.Gets the argument value that causes this exception.

Data Data Data Data

Ruft eine Auflistung von Schlüssel-Wert-Paaren ab, die zusätzliche benutzerdefinierte Informationen über die Ausnahme bereitstellen.Gets a collection of key/value pairs that provide additional user-defined information about the exception.

(Inherited from Exception)
HelpLink HelpLink HelpLink HelpLink

Ruft einen Link zur Hilfedatei ab, die dieser Ausnahme zugeordnet ist, oder legt einen Link fest.Gets or sets a link to the help file associated with this exception.

(Inherited from Exception)
HResult HResult HResult HResult

Ruft HRESULT ab oder legt HRESULT fest. Dies ist ein codierter Wert, der einer bestimmten Ausnahme zugeordnet ist.Gets or sets HRESULT, a coded numerical value that is assigned to a specific exception.

(Inherited from Exception)
InnerException InnerException InnerException InnerException

Ruft die Exception-Instanz ab, die die aktuelle Ausnahme verursacht hat.Gets the Exception instance that caused the current exception.

(Inherited from Exception)
Message Message Message Message

Ruft die Fehlermeldung und die Zeichenfolgendarstellung des ungültigen Argumentwerts oder nur die Fehlermeldung ab, wenn der Argumentwert Null ist.Gets the error message and the string representation of the invalid argument value, or only the error message if the argument value is null.

ParamName ParamName ParamName ParamName

Ruft den Namen des Parameters ab, der diese Ausnahme auslöst.Gets the name of the parameter that causes this exception.

(Inherited from ArgumentException)
Source Source Source Source

Gibt den Namen der Anwendung oder des Objekts zurück, die bzw. das den Fehler verursacht hat, oder legt diesen fest.Gets or sets the name of the application or the object that causes the error.

(Inherited from Exception)
StackTrace StackTrace StackTrace StackTrace

Ruft eine Zeichenfolgendarstellung der unmittelbaren Frames in der Aufrufliste ab.Gets a string representation of the immediate frames on the call stack.

(Inherited from Exception)
TargetSite TargetSite TargetSite TargetSite

Ruft die Methode ab, die die aktuelle Ausnahme auslöst.Gets the method that throws the current exception.

(Inherited from Exception)

Methoden

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Bestimmt, ob das angegebene Objekt mit dem aktuellen Objekt identisch ist.Determines whether the specified object is equal to the current object.

(Inherited from Object)
GetBaseException() GetBaseException() GetBaseException() GetBaseException()

Gibt beim Überschreiben in einer abgeleiteten Klasse eine Exception zurück, die die ursprüngliche Ursache für eine oder mehrere nachfolgende Ausnahmen ist.When overridden in a derived class, returns the Exception that is the root cause of one or more subsequent exceptions.

(Inherited from Exception)
GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Fungiert als Standardhashfunktion.Serves as the default hash function.

(Inherited from Object)
GetObjectData(SerializationInfo, StreamingContext) GetObjectData(SerializationInfo, StreamingContext) GetObjectData(SerializationInfo, StreamingContext) GetObjectData(SerializationInfo, StreamingContext)

Legt das SerializationInfo-Objekt mit dem ungültigen Argumentwert und zusätzlichen Informationen über die Ausnahme fest.Sets the SerializationInfo object with the invalid argument value and additional exception information.

GetType() GetType() GetType() GetType()

Ruft den Laufzeittyp der aktuellen Instanz ab.Gets the runtime type of the current instance.

(Inherited from Exception)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.Creates a shallow copy of the current Object.

(Inherited from Object)
ToString() ToString() ToString() ToString()

Erstellt eine Zeichenfolgendarstellung der aktuellen Ausnahme und gibt diese zurück.Creates and returns a string representation of the current exception.

(Inherited from Exception)

Ereignisse

SerializeObjectState SerializeObjectState SerializeObjectState SerializeObjectState

Tritt auf, wenn eine Ausnahme serialisiert wird, um ein Ausnahmezustandsobjekt mit serialisierten Daten über die Ausnahme zu erstellen.Occurs when an exception is serialized to create an exception state object that contains serialized data about the exception.

(Inherited from Exception)

Gilt für:

Siehe auch