ArgumentOutOfRangeException Klasse
TOC
Inhaltsverzeichnis reduzieren
Inhaltsverzeichnis erweitern
Dieser Artikel wurde maschinell übersetzt. Wenn Sie die englische Version des Artikels anzeigen möchten, aktivieren Sie das Kontrollkästchen Englisch. Sie können den englischen Text auch in einem Popupfenster anzeigen, indem Sie den Mauszeiger über den Text bewegen.
Übersetzung
Englisch

ArgumentOutOfRangeException-Klasse

 

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.

Namespace:   System
Assembly:  mscorlib (in mscorlib.dll)

System.Object
  System.Exception
    System.SystemException
      System.ArgumentException
        System.ArgumentOutOfRangeException

[SerializableAttribute]
[ComVisibleAttribute(true)]
public class ArgumentOutOfRangeException : ArgumentException, 
	ISerializable

NameBeschreibung
System_CAPS_pubmethodArgumentOutOfRangeException()

Initialisiert eine neue Instanz der ArgumentOutOfRangeException-Klasse.

System_CAPS_protmethodArgumentOutOfRangeException(SerializationInfo, StreamingContext)

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

System_CAPS_pubmethodArgumentOutOfRangeException(String)

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

System_CAPS_pubmethodArgumentOutOfRangeException(String, Exception)

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

System_CAPS_pubmethodArgumentOutOfRangeException(String, Object, String)

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

System_CAPS_pubmethodArgumentOutOfRangeException(String, String)

Initialisiert eine neue Instanz der ArgumentOutOfRangeException -Klasse mit dem Namen des Parameters, der bewirkt, diese Ausnahme und einer angegebenen Fehlermeldung dass.

NameBeschreibung
System_CAPS_pubpropertyActualValue

Ruft den Wert des Arguments, der diese Ausnahme verursacht hat.

System_CAPS_pubpropertyData

Ruft eine Auflistung von Schlüssel-Wert-Paaren ab, die zusätzliche benutzerdefinierte Informationen über die Ausnahme bereitstellen.(Geerbt von Exception.)

System_CAPS_pubpropertyHelpLink

Ruft einen Link zur Hilfedatei ab, die dieser Ausnahme zugeordnet ist, oder legt einen Link fest.(Geerbt von Exception.)

System_CAPS_pubpropertyHResult

Ruft HRESULT ab oder legt HRESULT fest. Dies ist ein codierter Wert, der einer bestimmten Ausnahme zugeordnet ist.(Geerbt von Exception.)

System_CAPS_pubpropertyInnerException

Ruft die Exception-Instanz ab, die die aktuelle Ausnahme verursacht hat.(Geerbt von Exception.)

System_CAPS_pubpropertyMessage

Ruft die Fehlermeldung und die Darstellung der ungültigen Argumentwert oder nur die Fehlermeldung ab, wenn der Wert des Arguments null ist.(Setzt "ArgumentException.Message" außer Kraft.)

System_CAPS_pubpropertyParamName

Ruft den Namen des Parameters ab, der diese Ausnahme auslöst.(Geerbt von ArgumentException.)

System_CAPS_pubpropertySource

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

System_CAPS_pubpropertyStackTrace

Ruft eine Zeichenfolgendarstellung der unmittelbaren Frames in der Aufrufliste ab.(Geerbt von Exception.)

System_CAPS_pubpropertyTargetSite

Ruft die Methode ab, die die aktuelle Ausnahme auslöst.(Geerbt von Exception.)

NameBeschreibung
System_CAPS_pubmethodEquals(Object)

Bestimmt, ob das angegebene Objekt mit dem aktuellen Objekt identisch ist.(Geerbt von Object.)

System_CAPS_protmethodFinalize()

Gibt einem Objekt Gelegenheit, Ressourcen freizugeben und andere Bereinigungen durchzuführen, bevor es von der Garbage Collection freigegeben wird. (Geerbt von Object.)

System_CAPS_pubmethodGetBaseException()

Gibt beim Überschreiben in einer abgeleiteten Klasse eine Exception zurück, die die ursprüngliche Ursache für eine oder mehrere nachfolgende Ausnahmen ist.(Geerbt von Exception.)

System_CAPS_pubmethodGetHashCode()

Fungiert als die Standardhashfunktion.(Geerbt von Object.)

System_CAPS_pubmethodGetObjectData(SerializationInfo, StreamingContext)

Legt die SerializationInfo -Objekt mit dem ungültigen Argumentwert und zusätzlichen Informationen zur Ausnahme.(Setzt "ArgumentException.GetObjectData(SerializationInfo, StreamingContext)" außer Kraft.)

System_CAPS_pubmethodGetType()

Ruft den Laufzeittyp der aktuellen Instanz ab.(Geerbt von Exception.)

System_CAPS_protmethodMemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.(Geerbt von Object.)

System_CAPS_pubmethodToString()

Erstellt eine Zeichenfolgendarstellung der aktuellen Ausnahme und gibt diese zurück.(Geerbt von Exception.)

NameBeschreibung
System_CAPS_proteventSerializeObjectState

Tritt auf, wenn eine Ausnahme serialisiert wird, um ein Ausnahmezustandsobjekt zu erstellen, das serialisierte Daten für die Ausnahme enthält.(Geerbt von Exception.)

Ein ArgumentOutOfRangeException Ausnahme wird ausgelöst, wenn eine Methode aufgerufen wird und mindestens eines der Argumente, die an die Methode übergebenen nicht null und enthält einen ungültigen Wert, der nicht Mitglied der Gruppe von Werten, die für das Argument erwartet ist. Die ParamName -Eigenschaft gibt das Argument ist ungültige, und die ActualValue -Eigenschaft, wenn ein Wert vorhanden ist, ist den ungültigen Wert identifiziert.

In der Regel eine ArgumentOutOfRangeException vom Entwickler Fehler führt. Statt die Ausnahme in eine try/catch blockieren, sollten Sie die Ursache der Ausnahme vermeiden, oder wenn das Argument wird von einem Methodenaufruf zurückgegeben oder Eingabe durch den Benutzer vor der Übergabe an die Methode, die die Ausnahme auslöst, sollten Sie Argumente überprüfen, bevor sie an die Methode übergeben.

ArgumentOutOfRangeException von wird häufig verwendet werden:

Die Bedingung in der eine ArgumentOutOfRangeException Ausnahme umfassen Folgendes:

Rufen Sie die Member einer Auflistung die Indexnummer und die Indexnummer ist ungültig.

Dies ist die häufigste Ursache für eine ArgumentOutOfRangeException Ausnahme. In der Regel ist die Indexnummer für eine der drei Gründe ungültig:

  • Die Auflistung enthält keine Mitglieder, und Ihr Code wird davon ausgegangen, dass dies der Fall ist. Im folgenden Beispiel wird versucht, auf das erste Element einer Auflistung abzurufen, die über keine Elemente verfügt:

    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
    

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

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

    In einigen Fällen kann dies auftreten, da Sie versuchen, ein Element zu einer Auflistung hinzufügen, mit dem Index, der nicht vorhanden ist und nicht durch Aufrufen der Methode, z. B. Add, für diesen Zweck vorhanden ist. Im folgenden Beispiel wird versucht, eine Auflistung ein Element hinzuzufügen, einen nicht vorhandenen Index verwenden, anstatt Aufrufen der List<T>.Add Methode.

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

    Das folgende Codefragment korrigiert diesen Fehler:

    var squares = new List<int>();
    for (int ctr = 0; ctr < numbers.Count; ctr++)
       squares.Add((int) Math.Pow(numbers[ctr], 2)); 
    
  • Sie versuchen, ein Element abgerufen, deren Index negativ ist. Dies tritt normalerweise auf, weil Sie eine Auflistung für den Index eines bestimmten Elements durchsucht haben, und Sie fälschlicherweise davon ausgegangen haben, dass die Suche erfolgreich ist. Im folgenden Beispiel der Aufruf der List<T>.FindIndex(Predicate<T>) Methode nicht finden kann, eine Zeichenfolge mit "Z" und können daher gibt-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
    

    Um die Ausnahme zu verhindern, überprüfen Sie, dass die Suche erfolgreich ist, und sicherstellen, dass der zurückgegebene Index größer als ist oder gleich 0 (null), bevor Sie versuchen, das Element aus der Auflistung abrufen, wie im folgenden Code-Fragment-ist.

    // 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]); 
    
  • Sie versuchen, ein Element abrufen, deren Index gleich dem Wert der Auflistung ist Count -Eigenschaft, wie im folgenden Beispiel illustriert.

    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
    

    Da Auflistungen in .NET Framework nullbasierte Indizierung verwendet verwenden, das erste Element der Auflistung, am Index 0 ist und das letzte Element am Index ist 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.

    // 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, eine Zeichenfolgenoperation auszuführen, indem eine Zeichenfolge Manipulation-Methode aufgerufen, und der Startindex in der Zeichenfolge nicht vorhanden.

Überladungen von Methoden wie z. B. String.Compare, String.CompareOrdinal, String.IndexOf, IndexOfAny, String.Insert, String.LastIndexOf, String.LastIndexOfAny, Remove, oder String.Substring mit denen Sie angeben, der Startindex für den Vorgang erforderlich, dass der Index eine gültige Position innerhalb der Zeichenfolge sein. Gültige Indizes im Bereich von 0 bis String.Length - 1.

Es gibt vier allgemeine Ursachen hierfür ArgumentOutOfRangeException Ausnahme:

  • Sie arbeiten mit einer leeren Zeichenfolge, oder String.Empty. Da die String.Length Eigenschaft 0 zurück, jeder Versuch Manipulieren von Index löst eine ArgumentOutOfRangeException Ausnahme. Das folgende Beispiel definiert eine GetFirstCharacter Methode, die das erste Zeichen einer Zeichenfolge zurückgibt. Wenn die Zeichenfolge leer ist, wie die Ergebniszeichenfolge, die an die Methode ist, löst die Methode eine ArgumentOutOfRangeException Ausnahme.

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

    Eliminieren Sie die Ausnahme, durch 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. Das folgende Codefragment, tut. In diesem Fall, wenn die Zeichenfolge null oder leer ist, die GetFirstCharacter -Methode gibt U + 0000 zurück.

    static char GetFirstCharacter(String s)
    {
       if (String.IsNullOrEmpty(s)) 
          return '\u0000';
       else   
          return s[0];
    }
    
  • Sie haben eine Zeichenfolge, die auf Grundlage der Position einer Teilzeichenfolge innerhalb dieser Zeichenfolge bearbeiten und konnte nicht ermitteln, ob tatsächlich die Teilzeichenfolge gefunden wurde.

    Im folgende Beispiel wird die zweite Wort oder einen Ausdruck zwei Wörtern extrahiert. Löst eine ArgumentOutOfRangeException -Ausnahme aus, wenn der Ausdruck besteht aus nur einem Wort, und daher kein eingebettetes Leerzeichen enthalten. Dies tritt auf, 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.

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

    Um die Ausnahme zu vermeiden, überprüfen Sie den Rückgabewert von Search-Methode die Zeichenfolge vor dem Aufrufen der String Manipulation-Methode.

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

Die Methoden, die Teilzeichenfolgen extrahieren Sie, die alle erfordern, dass Sie die Anfangsposition der Teilzeichenfolge und Teilzeichenfolgen, die nicht an das Ende der Zeichenfolge, die Anzahl der Zeichen der Teilzeichenfolge weiterhin angeben. Beachten Sie, dass dies nicht der Index des letzten Zeichens der Teilzeichenfolge.

Ein ArgumentOutOfRangeException Ausnahme wird normalerweise in diesem Fall ausgelöst, da Sie die Anzahl der Zeichen der Teilzeichenfolge falsch berechnet haben. Wenn Sie eine Suchmethode wie verwenden String.IndexOf die Anfangs- und Endposition einer Teilzeichenfolge identifiziert:

  • Wenn das Zeichen in der Endposition zurückgegebene String.IndexOf in der Teilzeichenfolge enthalten sein soll die Endposition der Teilzeichenfolge anhand der Formel

    endIndex - startIndex + 1
    
  • Wenn das Zeichen in der Endposition zurückgegebene String.IndexOf ist von der Teilzeichenfolge, ausgeschlossen werden die Endposition der Teilzeichenfolge anhand der Formel

    endIndex - startIndex 
    

Das folgende Beispiel definiert eine FindWords Methode, verwendet die String.IndexOfAny(Char[], Int32) Methode zur Identifizierung von Leerzeichen und Interpunktionszeichen in einer Zeichenfolge und gibt ein Array, das die Wörter in der Zeichenfolge 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++;
         }
         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 auf eine Methode mit einem Argument, das nur positive Zahlen und 0 (null) erfordert eine negative Zahl übergeben, oder eine negative Zahl oder 0 (null) an eine Methode mit einem Argument, das nur positive Zahlen erfordert bestanden wurden.

Zum Beispiel die Array.CreateInstance(Type, Int32, Int32, Int32) Methode erfordert, dass Sie die Anzahl der Elemente in jeder Dimension eines zweidimensionalen Arrays angeben, die für jede Dimension gültige Werte reichen von 0 bis Int32.MaxValue. Aber da im folgenden Beispiel wird das Dimension-Argument einen negativen Wert hat, löst die Methode eine ArgumentOutOfRangeException Ausnahme.

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

Um den Fehler zu beheben, stellen Sie sicher, dass der Wert des Arguments ungültig negativ ist. Sie können dazu bietet einen gültigen Wert, wie im folgenden Codefragment wird.

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

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

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);   
}
In einer Anwendung, die mehreren Threads oder Aufgaben, die asynchron ausgeführt und ein Array oder eine Auflistung, die aktualisiert, wurde, ist eine Racebedingung vorhanden.

Im folgenden Beispiel wird ein List<T> Objekt, das eine Auflistung von aufgefüllt Continent Objekte. Löst eine ArgumentOutOfRangeException -Ausnahme aus, wenn das Beispiel versucht, die sieben Elemente in der Auflistung anzeigen, bevor die Sammlung 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()

In diesem Fall sind zwei Ressourcen von mehreren Threads zugegriffen werden:

  • Die continents-Auflistung. Die List<T>.Add -Methode von mehreren Threads aufgerufen wird. Darüber hinaus der Haupt- oder primäre Thread Angenommen die Sammlung mit sieben Elementen vollständig aufgefüllt wird, wenn sie ihre Mitglieder durchläuft.

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

Um den Fehler zu beheben, stellen Sie sicher, dass freigegebenen Status wie folgt auf eine threadsichere Weise zugegriffen wird.

  • Wenn Ihre app ein Array- oder Auflistungselement-Objekt verwendet wird, erwägen Sie eine threadsichere Auflistung-Klasse, z. B. die Typen in der System.Collections.Concurrent Namespace oder die System.Collections.Immutable Out-of-Band-Version.

  • Stellen Sie sicher, dass gemeinsam verwendete Zustände (d. h. Ressourcen, die durch mehrere Threads zugegriffen werden kann) auf eine threadsichere Weise zugegriffen wird, damit jeweils nur ein Thread exklusiven Zugriff auf die Ressourcen verfügt. Eine große Anzahl von Klassen, wie z. B. CountdownEvent, Interlocked, Monitor, und Mutex, zum Synchronisieren des Zugriffs auf Ressourcen verfügbar sind. Weitere Informationen finden Sie unter Managed Threading. Darüber hinaus Unterstützung für Sprachen erhältlich ist die Sperre -Anweisung in c# und die SyncLock in Visual Basic erstellen.

Das folgende Beispiel-Adressen der ArgumentOutOfRangeException Ausnahme und die anderen Probleme aus dem vorherigen Beispiel. Ersetzt die List<T> -Objekt mit einer ConcurrentBag<T> Objekt, um sicherzustellen, dass der Zugriff auf die Auflistung threadsicher ist, verwendet ein CountdownEvent Objekt, um sicherzustellen, dass Thread der Anwendung fortgesetzt wird, wenn andere Threads ausgeführt und verwendet eine Sperre, um sicherzustellen, dass diese nur ein Thread auf zugreifen kann die msg Variablen gleichzeitig.

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

ArgumentOutOfRangeException verwendet HRESULT COR_E_ARGUMENTOUTOFRANGE mit den Wert 0 x 80131502.

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

Das folgende Beispiel definiert eine Klasse, um Informationen über einen eingeladenen Gast enthalten. Wenn der Gast jünger als 21 ist, ist eine ArgumentOutOfRangeException 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);
    }
}

Universal Windows Platform
Verfügbar seit 8
.NET Framework
Verfügbar seit 1.1
Portable Class Library
Unterstützt in: portable .NET platforms
Silverlight
Verfügbar seit 2.0
Windows Phone Silverlight
Verfügbar seit 7.0
Windows Phone
Verfügbar seit 8.1

Öffentliche statische (in Visual Basic freigegebene) Member dieses Typs sind threadsicher. Bei Instanzmembern ist die Threadsicherheit nicht gewährleistet.

Zurück zum Anfang
Anzeigen:
© 2016 Microsoft