ArgumentOutOfRangeException Klasse

Definition

Namespace:

System

Assembly:

System.Runtime.dll

Quelle:

ArgumentOutOfRangeException.cs

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.

C#

public class ArgumentOutOfRangeException : ArgumentException

Vererbung

Object

Exception

SystemException

ArgumentException

ArgumentOutOfRangeException

Beispiele

Im folgenden Beispiel wird eine Klasse definiert, die Informationen zu einem eingeladenen Gast enthält. Wenn der Gast jünger als 21 Ist, wird eine ArgumentOutOfRangeException Ausnahme ausgelöst.

C#

using System;
using static System.Console;

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

class Guest
{
    private const int minimumRequiredAge = 21;

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

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

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

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

Hinweise

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

In der Regel tritt ein ArgumentOutOfRangeException Entwicklerfehler auf. Anstatt die Ausnahme in einem try/catch -Block zu behandeln, sollten Sie die Ursache der Ausnahme beseitigen. Wenn das Argument von einem Methodenaufruf oder einer Eingabe vom Benutzer zurückgegeben wird, bevor sie an die Methode übergeben wird, die die Ausnahme auslöst, sollten Sie Argumente überprüfen, bevor Sie sie an die -Methode übergeben.

ArgumentOutOfRangeException wird häufig verwendet von:

• Klassen in den System.Collections Namespaces und System.IO

• Die Array-Klasse.

• Methoden zur Zeichenfolgenbearbeitung in der String -Klasse.

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

• Sie ruft den Member einer Auflistung anhand seiner Indexnummer ab, und die Indexnummer ist ungültig.

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

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

     C#

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

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

     C#

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

  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 , die für diesen Zweck vorhanden ist, Addaufzurufen. Im folgenden Beispiel wird versucht, einer Auflistung ein Element hinzuzufügen, indem ein nicht vorhandener Index verwendet wird, anstatt die List<T>.Add -Methode aufzurufen.

     C#

     using System;
     using System.Collections.Generic;
     
     public class Example13
     {
        public static void Main()
        {
           var numbers = new List<int>();
           numbers.AddRange( new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 20 } );
     
           var squares = new List<int>();
           for (int ctr = 0; ctr < numbers.Count; ctr++)
              squares[ctr] = (int) Math.Pow(numbers[ctr], 2);
        }
     }
     // The example displays the following output:
     //    Unhandled Exception: System.ArgumentOutOfRangeException: Index was out of range. Must be non-negative and less than the size of the collection.
     //    Parameter name: index
     //       at System.ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument argument, ExceptionResource resource)
     //       at Example.Main()
     

     Mit dem folgenden Codefragment wird dieser Fehler korrigiert:

     C#

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

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

     C#

     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
     

     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 ist, bevor Sie versuchen, das Element aus der Auflistung abzurufen, wie das folgende Codefragment dies tut.

     C#

     // 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]);
     

  4. Sie versuchen, ein Element abzurufen, dessen Index dem Wert der -Eigenschaft der Auflistung Count entspricht, wie im folgenden Beispiel veranschaulicht.

     C#

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

     Da Auflistungen in .NET die nullbasierte Indizierung verwenden, befindet sich das erste Element der Auflistung bei Index 0, und das letzte Element ist bei 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.

     C#

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

• Sie versuchen, einen Zeichenfolgenvorgang auszuführen, indem Sie eine Zeichenfolgenbearbeitungsmethode aufrufen, und der Startindex ist in der Zeichenfolge nicht vorhanden.

  Überladungen von Methoden wie String.Compare, String.CompareOrdinal, String.LastIndexOfString.IndexOfIndexOfAnyString.Insert, String.LastIndexOfAny, RemoveoderString.Substring, mit denen Sie den Startindex des Vorgangs angeben können, erfordern, dass der Index eine gültige Position innerhalb der Zeichenfolge ist. Gültige Indizes reichen von 0 bis 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 - String.Length Eigenschaft 0 zurückgibt, löst jeder Versuch, sie nach Index zu bearbeiten, eine Ausnahme aus ArgumentOutOfRangeException . Im folgenden Beispiel wird eine GetFirstCharacter Methode definiert, die das erste Zeichen einer Zeichenfolge zurückgibt. Wenn die Zeichenfolge leer ist, wie die endgültige Zeichenfolge, die an die -Methode übergeben wird, ist, löst die Methode eine Ausnahme aus ArgumentOutOfRangeException .

     C#

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

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

     C#

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

  2. Sie bearbeiten eine Zeichenfolge basierend auf der Position einer Teilzeichenfolge innerhalb dieser Zeichenfolge, und Sie konnten nicht ermitteln, ob die Teilzeichenfolge tatsächlich gefunden wurde.

     Im folgenden Beispiel wird das zweite Wort eines Zweiwortausdrucks extrahiert. Es löst eine Ausnahme aus ArgumentOutOfRangeException , wenn der Ausdruck nur aus einem Wort besteht und daher kein eingebettetes Leerzeichen enthält. Dies liegt daran, dass der Aufruf der String.IndexOf(String) -Methode -1 zurückgibt, um anzugeben, dass bei der Suche ein Fehler aufgetreten ist, und dieser ungültige Wert dann an die String.Substring(Int32) -Methode übergeben wird.

     C#

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

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

     C#

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

  3. Sie haben versucht, eine Teilzeichenfolge zu extrahieren, die sich außerhalb des Bereichs der aktuellen Zeichenfolge befindet.

     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 ArgumentOutOfRangeException Ausnahme ausgelöst, da Sie die Anzahl der Zeichen in der Teilzeichenfolge falsch berechnet haben. Wenn Sie eine Suchmethode wie String.IndexOf verwenden, um die Anfangs- und Endpositionen einer Teilzeichenfolge zu identifizieren:

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

       endIndex - startIndex + 1
       

     • Wenn das Zeichen in der Endposition, die von String.IndexOf zurückgegeben wird, aus der Teilzeichenfolge ausgeschlossen werden soll, wird die Endposition der Teilzeichenfolge durch die Formel angegeben.

       endIndex - startIndex
       

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

       C#

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

• Sie haben eine negative Zahl an eine Methode mit einem Argument übergeben, das nur positive Zahlen und Null erfordert, oder Sie haben entweder eine negative Zahl oder null an eine Methode mit einem Argument übergeben, das nur positive Zahlen erfordert.

  Die -Methode erfordert beispielsweise, Array.CreateInstance(Type, Int32, Int32, Int32) 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 Int32.MaxValueliegen. Da das Dimensionsargument im folgenden Beispiel jedoch einen negativen Wert aufweist, löst die Methode eine Ausnahme aus ArgumentOutOfRangeException .

  C#

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

  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 angeben, wie das folgende Codefragment dies tut.

  C#

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

  Sie können die Eingabe auch überprüfen und, wenn sie ungültig ist, eine Aktion ausführen. Das folgende Codefragment zeigt eine Fehlermeldung an, anstatt die -Methode aufzurufen.

  C#

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

• Eine Racebedingung ist in einer App vorhanden, die multithreaded ist oder Über Aufgaben verfügt, die asynchron ausgeführt werden und die ein Array oder eine Sammlung aktualisiert.

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

  C#

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

  In diesem Fall wird über mehrere Threads auf zwei Ressourcen zugegriffen:

  • Die continents-Auflistung. Die List<T>.Add -Methode wird aus mehreren Threads aufgerufen. Darüber hinaus geht der Standard- oder primärer Thread davon aus, dass die Auflistung vollständig mit sieben Elementen gefüllt ist, wenn sie ihre Member durchläuft.

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

  Stellen Sie zum Beheben des Fehlers sicher, dass auf den freigegebenen Zustand wie folgt zugegriffen wird.

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

  • Stellen Sie sicher, dass auf den freigegebenen Zustand (d. h. auf Ressourcen, auf die mehrere Threads zugreifen können) threadsicher zugegriffen wird, sodass jeweils nur ein Thread exklusiven Zugriff auf die Ressourcen hat. Eine große Anzahl von Klassen, z CountdownEvent. B. , Interlocked, Monitorund Mutex, stehen zum Synchronisieren des Zugriffs auf Ressourcen zur Verfügung. Weitere Informationen finden Sie unter Threading. Darüber hinaus ist die Sprachunterstützung über die Lock-Anweisung in C# und das SyncLock-Konstrukt in Visual Basic verfügbar.

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

  C#

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

ArgumentOutOfRangeException verwendet die HRESULT-COR_E_ARGUMENTOUTOFRANGE, die den Wert 0x80131502 hat.

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)	Veraltet. 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)	Veraltet. Legt das SerializationInfo-Objekt mit dem ungültigen Argumentwert und zusätzlichen Informationen über die Ausnahme fest.
GetType()	Ruft den Laufzeittyp der aktuellen Instanz ab. (Geerbt von Exception)
MemberwiseClone()	Erstellt eine flache Kopie des aktuellen Object. (Geerbt von Object)
ThrowIfEqual<T>(T, T, String)	Löst eine ArgumentOutOfRangeException aus, wenn value gleich otherist.
ThrowIfGreaterThan<T>(T, T, String)	Löst eine ArgumentOutOfRangeException aus, wenn value größer als otherist.
ThrowIfGreaterThanOrEqual<T>(T, T, String)	Löst eine ArgumentOutOfRangeException aus, wenn value größer oder gleich otherist.
ThrowIfLessThan<T>(T, T, String)	Löst eine aus ArgumentOutOfRangeException , wenn value kleiner als otherist.
ThrowIfLessThanOrEqual<T>(T, T, String)	Löst eine aus ArgumentOutOfRangeException , wenn value kleiner oder gleich otherist.
ThrowIfNegative<T>(T, String)	Löst einen ArgumentOutOfRangeException aus, wenn value negativ ist.
ThrowIfNegativeOrZero<T>(T, String)	Löst eine aus ArgumentOutOfRangeException , wenn value negativ oder null ist.
ThrowIfNotEqual<T>(T, T, String)	Löst eine ArgumentOutOfRangeException aus, wenn value nicht gleich otherist.
ThrowIfZero<T>(T, String)	Löst ein ArgumentOutOfRangeException aus, wenn value null ist.
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:

Weitere Informationen

• Exception