Cet article a fait l’objet d’une traduction automatique. Pour afficher l’article en anglais, activez la case d’option Anglais. Vous pouvez également afficher le texte anglais dans une fenêtre contextuelle en faisant glisser le pointeur de la souris sur le texte traduit.
Traduction
Anglais

ArgumentOutOfRangeException, classe

 

Exception levée quand la valeur d’un argument n’appartient pas à la plage de valeurs autorisées, comme défini par la méthode appelée.

Espace de noms:   System
Assembly:  mscorlib (dans mscorlib.dll)

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

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

NomDescription
System_CAPS_pubmethodArgumentOutOfRangeException()

Initialise une nouvelle instance de la classe ArgumentOutOfRangeException.

System_CAPS_protmethodArgumentOutOfRangeException(SerializationInfo, StreamingContext)

Initialise une nouvelle instance de la classe ArgumentOutOfRangeException avec des données sérialisées.

System_CAPS_pubmethodArgumentOutOfRangeException(String)

Initialise une nouvelle instance de la ArgumentOutOfRangeException classe avec le nom du paramètre ayant provoqué cette exception.

System_CAPS_pubmethodArgumentOutOfRangeException(String, Exception)

Initialise une nouvelle instance de la ArgumentOutOfRangeException classe avec un message d’erreur spécifié et l’exception ayant provoqué cette exception.

System_CAPS_pubmethodArgumentOutOfRangeException(String, Object, String)

Initialise une nouvelle instance de la ArgumentOutOfRangeException classe avec le paramètre name, la valeur de l’argument et un message d’erreur spécifié.

System_CAPS_pubmethodArgumentOutOfRangeException(String, String)

Initialise une nouvelle instance de la ArgumentOutOfRangeException classe avec le nom du paramètre ayant provoqué cette exception et un message d’erreur spécifié.

NomDescription
System_CAPS_pubpropertyActualValue

Obtient la valeur de l’argument ayant provoqué cette exception.

System_CAPS_pubpropertyData

Obtient une collection de paires clé/valeur qui fournissent des informations supplémentaires définies par l'utilisateur sur l'exception.(Hérité de Exception.)

System_CAPS_pubpropertyHelpLink

Obtient ou définit un lien vers le fichier d'aide associé à cette exception.(Hérité de Exception.)

System_CAPS_pubpropertyHResult

Obtient ou définit HRESULT, valeur numérique codée qui est assignée à une exception spécifique.(Hérité de Exception.)

System_CAPS_pubpropertyInnerException

Obtient l'instance Exception qui a provoqué l'exception actuelle.(Hérité de Exception.)

System_CAPS_pubpropertyMessage

Obtient le message d'erreur et la représentation sous forme de chaîne de la valeur d'argument non valide, ou le message d'erreur uniquement si la valeur de l'argument est null.(Remplace ArgumentException.Message.)

System_CAPS_pubpropertyParamName

Obtient le nom du paramètre qui a provoqué cette exception.(Hérité de ArgumentException.)

System_CAPS_pubpropertySource

Obtient ou définit le nom de l'application ou de l'objet qui est à l'origine de l'erreur.(Hérité de Exception.)

System_CAPS_pubpropertyStackTrace

Obtient une représentation sous forme de chaîne des objets immédiats sur la pile des appels. (Hérité de Exception.)

System_CAPS_pubpropertyTargetSite

Obtient la méthode qui lève l'exception actuelle.(Hérité de Exception.)

NomDescription
System_CAPS_pubmethodEquals(Object)

Détermine si l'objet spécifié est identique à l'objet actuel.(Hérité de Object.)

System_CAPS_protmethodFinalize()

Autorise un objet à tenter de libérer des ressources et d'exécuter d'autres opérations de nettoyage avant qu'il ne soit récupéré par l'opération garbage collection. (Hérité de Object.)

System_CAPS_pubmethodGetBaseException()

En cas de substitution dans une classe dérivée, retourne la Exception qui est à l'origine d'une ou de plusieurs exceptions ultérieures.(Hérité de Exception.)

System_CAPS_pubmethodGetHashCode()

Fait office de fonction de hachage par défaut.(Hérité de Object.)

System_CAPS_pubmethodGetObjectData(SerializationInfo, StreamingContext)

Définit le SerializationInfo objet avec la valeur d'argument non valide et les informations d'exception supplémentaires.(Remplace ArgumentException.GetObjectData(SerializationInfo, StreamingContext).)

System_CAPS_pubmethodGetType()

Obtient le type au moment de l'exécution de l'instance actuelle.(Hérité de Exception.)

System_CAPS_protmethodMemberwiseClone()

Crée une copie superficielle du Object actuel.(Hérité de Object.)

System_CAPS_pubmethodToString()

Crée et retourne une chaîne représentant l'exception actuelle.(Hérité de Exception.)

NomDescription
System_CAPS_proteventSerializeObjectState

Se produit quand une exception est sérialisée pour créer un objet d'état d'exception qui contient des données sérialisées concernant l'exception.(Hérité de Exception.)

Un ArgumentOutOfRangeException exception est levée lorsqu’une méthode est appelée et au moins un des arguments passés à la méthode n’est pas null et contient une valeur non valide qui n’est pas membre du jeu de valeurs attendues pour l’argument. Le ParamName propriété identifie l’argument non valide et le ActualValue propriété, si une valeur est présente, identifie la valeur non valide.

En règle générale, un ArgumentOutOfRangeException résulte d’une erreur de développeur. Au lieu de traiter l’exception dans un try/catch bloc, vous devez éliminer la cause de l’exception ou, si l’argument est retournée par un appel de méthode ou d’une entrée par l’utilisateur avant d’être passé à la méthode qui lève l’exception, vous devez valider les arguments avant de les passer à la méthode.

ArgumentOutOfRangeException est fréquemment utilisé par :

Les conditions dans lesquelles un ArgumentOutOfRangeException d’exception sont les suivantes :

Vous récupérez le membre d’une collection par son numéro d’index, et le numéro d’index n’est pas valide.

Ceci est la cause la plus courante d’une ArgumentOutOfRangeException exception. En règle générale, le numéro d’index n’est pas valide pour l’une des trois raisons :

  • La collection ne possède aucun membre, et votre code part du principe qu’il effectue. L’exemple suivant tente de récupérer le premier élément d’une collection qui ne comporte aucun élément :

    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
    

    Pour empêcher cette exception, vérifiez si la collection Count propriété est supérieure à zéro avant d’essayer de récupérer tous les membres, comme le fait le fragment de code suivant.

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

    Dans certains cas, cela peut se produire parce que vous tentez d’ajouter un membre à une collection à l’aide d’un index qui n’existe pas, plutôt qu’en appelant la méthode, tel que Add, qui existe à cet effet. L’exemple suivant tente d’ajouter un élément à une collection en utilisant un index inexistant, au lieu d’appeler le List<T>.Add (méthode).

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

    Le fragment de code suivant corrige cette erreur :

    var squares = new List<int>();
    for (int ctr = 0; ctr < numbers.Count; ctr++)
       squares.Add((int) Math.Pow(numbers[ctr], 2)); 
    
  • Vous tentez de récupérer un élément dont l’index est négatif. Cela se produit généralement parce que vous avez recherché un regroupement pour l’index d’un élément particulier et avez considéré à tort comme que la recherche a réussi. Dans l’exemple suivant, l’appel à la List<T>.FindIndex(Predicate<T>) méthode ne parvient pas à trouver une chaîne égale à « Z » et ainsi retourne -1. Toutefois, il s’agit d’une valeur d’index non valide.

    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
    

    Pour empêcher cette exception, vérifiez que la recherche a réussi en vous assurant qu’index retourné est supérieure ou égale à zéro avant de tenter de récupérer l’élément de la collection, comme le code suivant fragment le fait.

    // 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]); 
    
  • Vous tentez de récupérer un élément dont l’index est égale à la valeur de la collection Count propriété, comme l’exemple suivant l’illustre.

    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
    

    Étant donné que les collections dans le .NET Framework utilisent une indexation de base zéro, le premier élément de la collection est à l’index 0 et le dernier élément est à l’index Count - 1. Vous pouvez éliminer l’erreur accès le dernier élément à l’index Count - 1, comme le fait le code suivant.

    // Display the elements in the list by index.
    for (int ctr = 0; ctr < list.Count; ctr++) 
       Console.WriteLine("Index {0}: {1}", ctr, list[ctr]);
    
Vous tentez d’effectuer une opération de chaîne en appelant une méthode de manipulation de chaîne et l’index de départ n’existe pas dans la chaîne.

Les surcharges des méthodes telles que comme String.Compare, String.CompareOrdinal, String.IndexOf, IndexOfAny, String.Insert, String.LastIndexOf, String.LastIndexOfAny, Remove, ou String.Substring vous permettent de spécifier l’index de départ de l’opération requiert que l’index à une position valide dans la chaîne. Index valides comprise entre 0 et String.Length - 1.

Il existe quatre causes courantes de cet ArgumentOutOfRangeException exception :

  • Vous travaillez avec une chaîne vide., ou String.Empty. Étant donné que son String.Length propriété retourne 0, toute tentative de les manipuler à index lève une ArgumentOutOfRangeException exception. L’exemple suivant, définit un GetFirstCharacter méthode qui retourne le premier caractère d’une chaîne. Si la chaîne est vide, comme la dernière chaîne passée à la méthode, la méthode lève un 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()
    

    Vous pouvez éliminer l’exception en vérifiant si la chaîne String.Length est supérieur ou égal à zéro ou en appelant le IsNullOrEmpty pour s’assurer que la chaîne n’est pas null ou vide. Le fragment de code suivant effectue ce dernier. Dans ce cas, si la chaîne est null ou vide, le GetFirstCharacter méthode retourne U + 0000.

    static char GetFirstCharacter(String s)
    {
       if (String.IsNullOrEmpty(s)) 
          return '\u0000';
       else   
          return s[0];
    }
    
  • Vous manipulez une chaîne basée sur la position d’une sous-chaîne dans cette chaîne, et vous avez Impossible de déterminer si la sous-chaîne a été trouvée.

    L’exemple suivant extrait le deuxième mot d’une phrase deux mots. Elle lève une ArgumentOutOfRangeException exception si l’expression se compose d’un mot et par conséquent ne contient pas un caractère espace incorporé. Cela se produit car l’appel à la String.IndexOf(String) méthode retourne -1 pour indiquer que la recherche a échoué, et cette valeur non valide est passée ensuite à la String.Substring(Int32) (méthode).

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

    Pour éliminer l’exception, valider la valeur retournée par la méthode de recherche de chaîne avant d’appeler la méthode de manipulation de chaînes.

    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
    
Vous avez tenté d’extraire une sous-chaîne qui se trouve en dehors de la plage de la chaîne actuelle.

Les méthodes qui extraient les sous-chaînes que toutes nécessitent que vous spécifiez la position de départ de la sous-chaîne et, pour les sous-chaînes qui ne continuent pas à la fin de la chaîne, le nombre de caractères dans la sous-chaîne. Notez que ce n’est pas le index du dernier caractère de la sous-chaîne.

Un ArgumentOutOfRangeException exception est généralement levée dans ce cas parce que vous avez calculées correctement le nombre de caractères dans la sous-chaîne. Si vous utilisez une méthode de recherche comme String.IndexOf pour identifier le début et fin des positions d’une sous-chaîne :

  • Si le caractère à la position de fin est retourné par String.IndexOf doit être inclus dans la sous-chaîne, la position de fin de la sous-chaîne est donnée par la formule

    endIndex - startIndex + 1
    
  • Si le caractère à la position de fin est retourné par String.IndexOf est exclus de la sous-chaîne, la position de fin de la sous-chaîne est donnée par la formule

    endIndex - startIndex 
    

L’exemple suivant définit un FindWords méthode qui utilise le String.IndexOfAny(Char[], Int32) méthode pour identifier les espaces et la ponctuation marque dans une chaîne et retourne un tableau qui contient les mots trouvés dans la chaîne.

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'
Vous avez transmis une valeur négative à une méthode avec un argument qui nécessite uniquement des nombres positifs et zéro ou que vous avez passé un nombre négatif ou égal à zéro à une méthode avec un argument qui nécessite uniquement des nombres positifs.

Par exemple, le Array.CreateInstance(Type, Int32, Int32, Int32) méthode nécessite que vous spécifiez le nombre d’éléments dans chaque dimension d’un tableau à deux dimensions, les valeurs valides pour chaque dimension peuvent être comprise entre 0 et Int32.MaxValue. Mais étant donné que l’argument de dimension dans l’exemple suivant a une valeur négative, la méthode lève un 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

Pour corriger cette erreur, assurez-vous que la valeur de l’argument non valide est négative. Vous pouvez cela en fournissant une valeur valide, comme le fait le fragment de code suivant.

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

Vous pouvez également valider l’entrée et, si elle n’est pas valide, prendre des mesures. Le fragment de code suivant affiche un message d’erreur au lieu d’appeler la méthode.

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);   
}
Il existe une condition de concurrence dans une application multithread ou dont les tâches qui s’exécutent en mode asynchrone et qui met à jour un tableau ou une collection.

L’exemple suivant utilise un List<T> pour remplir une collection d’objets Continent objets. Elle lève une ArgumentOutOfRangeException exception si l’exemple tente d’afficher les sept éléments dans la collection avant de la collection est entièrement remplie.

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

Dans ce cas, les deux ressources sont accessibles à partir de plusieurs threads :

  • Le continents collection. Son List<T>.Add méthode est appelée à partir de plusieurs threads. En outre, le thread principale suppose que la collection est entièrement remplie avec sept éléments lorsqu’il itère au sein de ses membres.

  • Le msg chaîne, qui est concaténée à partir de plusieurs threads.

Pour corriger cette erreur, vérifiez qu’état partagé est accessible de manière thread-safe, comme suit.

  • Si votre application utilise un objet array ou de collection, envisagez d’utiliser une classe de collection thread-safe, telles que les types dans les System.Collections.Concurrent espace de noms ou le System.Collections.Immutable version hors-bande.

  • Assurez-vous que l’état partagé (autrement dit, les ressources qui sont accessibles par plusieurs threads) est accessible de manière thread-safe, afin qu’un seul thread à la fois dispose d’un accès exclusif aux ressources. Un grand nombre de classes, telles que CountdownEvent, Interlocked, Monitor, et Mutex, sont disponibles pour synchroniser l’accès aux ressources. Pour plus d'informations, consultez Managed Threading. En outre, la prise en charge linguistique est disponible via le verrou instruction en langage c# et le SyncLock construire dans Visual Basic.

Les exemples d’adresses suivantes du ArgumentOutOfRangeException exception et les autres problèmes de l’exemple précédent. Il remplace le List<T> de l’objet avec un ConcurrentBag<T> objet pour s’assurer que l’accès à la collection est thread-safe, utilise un CountdownEvent objet pour s’assurer que le thread d’application se poursuit uniquement après les autres threads ont été exécutés, et utilise un verrou pour garantir que seul un thread peut accéder à la msg variable à la fois.

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 utilise le HRESULT COR_E_ARGUMENTOUTOFRANGE dont la valeur est 0 x 80131502.

Pour obtenir la liste des valeurs initiales des propriétés d’une instance de ArgumentOutOfRangeException, consultez la ArgumentOutOfRangeException constructeurs.

L’exemple suivant définit une classe pour contenir des informations sur un invité invité. Si l’invité a moins de 21 ans un ArgumentOutOfRangeException exception est levée.

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
Disponible depuis 8
.NET Framework
Disponible depuis 1.1
Portable Class Library
Pris en charge dans : portable .NET platforms
Silverlight
Disponible depuis 2.0
Windows Phone Silverlight
Disponible depuis 7.0
Windows Phone
Disponible depuis 8.1

Tous les membres statiques (Shared en Visual Basic) publics de ce type sont thread-safe. Il n'est pas garanti que les membres d'instance soient thread-safe.

Retour au début
Afficher: