Questo articolo è stato tradotto automaticamente. Per visualizzare l'articolo in inglese, selezionare la casella di controllo Inglese. È possibile anche visualizzare il testo inglese in una finestra popup posizionando il puntatore del mouse sopra il testo.
Traduzione
Inglese

Classe ArgumentOutOfRangeException

 

Data di pubblicazione: ottobre 2016

Eccezione generata quando il valore di un argomento non è compreso nell'intervallo consentito di valori, come definito dal metodo richiamato.

Spazio dei nomi:   System
Assembly:  mscorlib (in mscorlib.dll)

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

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

NomeDescrizione
System_CAPS_pubmethodArgumentOutOfRangeException()

Inizializza una nuova istanza della classe ArgumentOutOfRangeException.

System_CAPS_protmethodArgumentOutOfRangeException(SerializationInfo, StreamingContext)

Inizializza una nuova istanza della classe ArgumentOutOfRangeException con dati serializzati.

System_CAPS_pubmethodArgumentOutOfRangeException(String)

Inizializza una nuova istanza della classe ArgumentOutOfRangeException con il nome del parametro che causa l'eccezione.

System_CAPS_pubmethodArgumentOutOfRangeException(String, Exception)

Inizializza una nuova istanza della classe ArgumentOutOfRangeException con un messaggio di errore e l'eccezione che ha causato l'eccezione corrente.

System_CAPS_pubmethodArgumentOutOfRangeException(String, Object, String)

Inizializza una nuova istanza di ArgumentOutOfRangeException nome della classe con il parametro, il valore dell'argomento e un messaggio di errore specificato.

System_CAPS_pubmethodArgumentOutOfRangeException(String, String)

Inizializza una nuova istanza di ArgumentOutOfRangeException classe con il nome di parametro che ha causato questa eccezione e un messaggio di errore specificato.

NomeDescrizione
System_CAPS_pubpropertyActualValue

Ottiene il valore dell'argomento che ha causato questa eccezione.

System_CAPS_pubpropertyData

Ottiene una collezione di coppie chiave/valore che forniscono ulteriori informazioni definite dall'utente sull'eccezione. (Ereditato da Exception.)

System_CAPS_pubpropertyHelpLink

Ottiene o imposta un collegamento al file della Guida associato all'eccezione.(Ereditato da Exception.)

System_CAPS_pubpropertyHResult

Ottiene o imposta HRESULT, un valore numerico codificato che viene assegnato ad una specifica eccezione. (Ereditato da Exception.)

System_CAPS_pubpropertyInnerException

Ottiene l'istanza di Exception che ha causato l'eccezione corrente.(Ereditato da Exception.)

System_CAPS_pubpropertyMessage

Ottiene il messaggio di errore e la rappresentazione di stringa del valore dell'argomento non valido o solo il messaggio di errore se il valore dell'argomento è null.(Esegue l'override di ArgumentException.Message.)

System_CAPS_pubpropertyParamName

Ottiene il nome del parametro che ha causato questa eccezione.(Ereditato da ArgumentException.)

System_CAPS_pubpropertySource

Ottiene o imposta il nome dell'oggetto o dell'applicazione che ha generato l'errore.(Ereditato da Exception.)

System_CAPS_pubpropertyStackTrace

Ottiene una rappresentazione in forma di stringa dei frame nello stack di chiamate. (Ereditato da Exception.)

System_CAPS_pubpropertyTargetSite

Ottiene il metodo che ha generato l'eccezione corrente. (Ereditato da Exception.)

NomeDescrizione
System_CAPS_pubmethodEquals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente. (Ereditato da Object.)

System_CAPS_protmethodFinalize()

Consente a un oggetto di provare a liberare risorse ed eseguire altre operazioni di pulizia prima che l'oggetto stesso venga reclamato dalla procedura di Garbage Collection. (Ereditato da Object.)

System_CAPS_pubmethodGetBaseException()

Quando ne viene eseguito l'override in una classe derivata, restituisce l'Exception che è la causa radice di una o più eccezioni successive.(Ereditato da Exception.)

System_CAPS_pubmethodGetHashCode()

Funge da funzione hash predefinita.(Ereditato da Object.)

System_CAPS_pubmethodGetObjectData(SerializationInfo, StreamingContext)

Set di SerializationInfo oggetto con il valore dell'argomento non valido e informazioni aggiuntive sull'eccezione.(Esegue l'override di ArgumentException.GetObjectData(SerializationInfo, StreamingContext).)

System_CAPS_pubmethodGetType()

Ottiene il tipo di runtime dell'istanza corrente.(Ereditato da Exception.)

System_CAPS_protmethodMemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.(Ereditato da Object.)

System_CAPS_pubmethodToString()

Crea e restituisce una rappresentazione di stringa dell'eccezione corrente.(Ereditato da Exception.)

NomeDescrizione
System_CAPS_proteventSerializeObjectState

Si verifica quando un'eccezione viene serializzata per creare un oggetto di stato eccezione contenente i dati serializzati relativi all'eccezione.(Ereditato da Exception.)

Un ArgumentOutOfRangeException viene generata quando viene richiamato un metodo e almeno uno degli argomenti passati al metodo non null e contiene un valore non valido che non è un membro del set di valori previsti per l'argomento. Il ParamName proprietà identifica l'argomento non valido e ActualValue proprietà, se è presente, un valore identifica il valore non valido.

In genere, un ArgumentOutOfRangeException risultante dall'errore per gli sviluppatori. Invece di gestire l'eccezione in un try/catch blocco, pertanto è necessario eliminare la causa dell'eccezione o, se l'argomento è stato restituito da una chiamata al metodo o di input dall'utente prima di essere passata al metodo che genera l'eccezione, è necessario convalidare gli argomenti prima di passarli al metodo.

ArgumentOutOfRangeException è ampiamente utilizzato da:

Le condizioni in cui un ArgumentOutOfRangeException viene generata un'eccezione includono quanto segue:

Si recupera il membro di una raccolta con il relativo numero di indice e il numero di indice non valido.

Questa è la causa più comune di un ArgumentOutOfRangeException (eccezione). In genere, il numero di indice è non valido per uno dei tre motivi:

  • La raccolta non dispone di membri e il codice si presuppone che esegue. Nell'esempio seguente tenta di recuperare il primo elemento di una raccolta che non dispone di elementi:

    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
    

    Per impedire l'eccezione, controllare se la raccolta Count proprietà è maggiore di zero prima di tentare di recuperare tutti i membri, come nel seguente frammento di codice.

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

    In alcuni casi, ciò potrebbe verificarsi se si sta tentando di aggiungere un membro a una raccolta utilizzando un indice che non esiste, anziché chiamare il metodo, ad esempio Add, che esista per questo scopo. Nell'esempio seguente tenta di aggiungere un elemento a una raccolta utilizzando un indice inesistente, anziché chiamare il List<T>.Add metodo.

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

    Nel frammento di codice seguente consente di correggere questo errore:

    var squares = new List<int>();
    for (int ctr = 0; ctr < numbers.Count; ctr++)
       squares.Add((int) Math.Pow(numbers[ctr], 2)); 
    
  • Si sta tentando di recuperare un elemento il cui indice è negativo. Ciò accade solitamente perché una raccolta per l'indice di un particolare elemento di ricerca e avere erroneamente presuppone che la ricerca ha esito positivo. Nell'esempio seguente, la chiamata al List<T>.FindIndex(Predicate<T>) metodo non riesce a trovare una stringa uguale a "Z" e pertanto restituisce -1. Tuttavia, questo è un valore di indice non valido.

    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
    

    Per evitare l'eccezione, verificare che la ricerca ha esito positivo, verificare che l'indice restituito è maggiore o uguale a zero prima di tentare di recuperare l'elemento dalla raccolta, come il codice seguente frammento non.

    // 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]); 
    
  • Si sta tentando di recuperare un elemento il cui indice è uguale al valore della proprietà Count proprietà, come nell'esempio seguente viene illustrato.

    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
    

    Poiché le raccolte in .NET Framework utilizzano l'indicizzazione in base zero, il primo elemento della raccolta è in corrispondenza dell'indice 0 ed è l'ultimo elemento in corrispondenza dell'indice Count - 1. È possibile eliminare l'errore, assicurarsi che accedere all'ultimo elemento in corrispondenza dell'indice Count - 1, come avviene con il codice seguente.

    // Display the elements in the list by index.
    for (int ctr = 0; ctr < list.Count; ctr++) 
       Console.WriteLine("Index {0}: {1}", ctr, list[ctr]);
    
Si sta tentando di eseguire un'operazione di stringa chiamando un metodo di modifica della stringa e l'indice iniziale non esiste nella stringa.

Overload di metodi come, ad esempio String.Compare, String.CompareOrdinal, String.IndexOf, IndexOfAny, String.Insert, String.LastIndexOf, String.LastIndexOfAny, Remove, o String.Substring che consentono di specificare l'indice iniziale dell'operazione è necessario che l'indice sia una posizione valida all'interno della stringa. Gli indici validi intervallo da 0 a String.Length - 1.

Esistono quattro cause comuni di questo ArgumentOutOfRangeException eccezione:

  • Si lavora con una stringa vuota., o String.Empty. Poiché il relativo String.Length restituisce 0, qualsiasi tentativo di modificarla per indice genera un ArgumentOutOfRangeException (eccezione). L'esempio seguente definisce una GetFirstCharacter metodo che restituisce il primo carattere di una stringa. Se la stringa è vuota, come la stringa finale passato al metodo, il metodo genera un ArgumentOutOfRangeException (eccezione).

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

    È possibile eliminare l'eccezione verificando se la stringa String.Length è maggiore di zero o chiamando il IsNullOrEmpty metodo per assicurarsi che la stringa non è null o vuoto. Nel frammento di codice seguente esegue quest'ultimo. In questo caso, se la stringa è null o vuoto, il GetFirstCharacter restituisce U + 0000.

    static char GetFirstCharacter(String s)
    {
       if (String.IsNullOrEmpty(s)) 
          return '\u0000';
       else   
          return s[0];
    }
    
  • Si sta modificando una stringa in base alla posizione di una sottostringa all'interno di tale stringa e non riuscita determinare se effettivamente è stata trovata la sottostringa.

    Nell'esempio seguente estrae la seconda parola di una frase due parole. Genera un ArgumentOutOfRangeException eccezione se la frase è costituito solo da una parola e pertanto non contiene un carattere di spazio. Ciò si verifica perché la chiamata al String.IndexOf(String) -1 per indicare che la ricerca non è riuscita e il valore non valido viene quindi passato al metodo viene restituito il String.Substring(Int32) (metodo).

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

    Per eliminare l'eccezione, convalidare il valore restituito dal metodo di ricerca stringa prima di chiamare il metodo di modifica di stringhe.

    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
    
Si è tentato di estrarre una sottostringa che non rientra nell'intervallo della stringa corrente.

I metodi che consentono di estrarre sottostringhe che tutto è necessario specificare la posizione iniziale della sottostringa e, per sottostringhe non proseguono fino alla fine della stringa, il numero di caratteri nella sottostringa. Si noti che non si tratta di indice dell'ultimo carattere nella sottostringa.

Un ArgumentOutOfRangeException viene in genere generata eccezione in questo caso perché si è calcolato in modo errato il numero di caratteri nella sottostringa. Se si utilizza un metodo di ricerca come String.IndexOf per identificare l'avvio e la posizione di una sottostringa finale:

  • Se il carattere nella posizione finale restituito da String.IndexOf deve essere incluso nella sottostringa, la posizione finale della sottostringa è dato dalla formula

    endIndex - startIndex + 1
    
  • Se il carattere nella posizione finale restituito da String.IndexOf devono essere esclusi dalla sottostringa, la posizione finale della sottostringa è dato dalla formula

    endIndex - startIndex 
    

L'esempio seguente definisce una FindWords metodo che utilizza il String.IndexOfAny(Char[], Int32) metodo per identificare gli spazi e punteggiatura contrassegna in una stringa e restituisce una matrice che contiene le parole trovate nella stringa.

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'
È stato passato un numero negativo a un metodo con un argomento che richiede solo numeri positivi e zero o è stato passato un numero negativo o zero a un metodo con un argomento che richiede solo numeri positivi.

Ad esempio, il Array.CreateInstance(Type, Int32, Int32, Int32) metodo è necessario specificare il numero di elementi in ogni dimensione di una matrice bidimensionale; i valori validi per ogni dimensione possono variare da 0 a Int32.MaxValue. Ma poiché l'argomento di dimensione nell'esempio seguente contiene un valore negativo, il metodo genera un ArgumentOutOfRangeException (eccezione).

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

Per correggere l'errore, assicurarsi che il valore dell'argomento non valido è un valore non negativo. È possibile farlo, fornendo un valore valido, come nel seguente frammento di codice.

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

È possibile anche convalidare l'input e, se non è valido, eseguire un'azione. Nel frammento di codice seguente viene visualizzato un messaggio di errore anziché chiamare il metodo.

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);   
}
Tale condizione si verifica in un'applicazione multithreading o con le attività che consentono di eseguire in modo asincrono e che consente di aggiornare una matrice o raccolta.

Nell'esempio seguente viene utilizzato un List<T> oggetto per popolare una raccolta di Continent oggetti. Genera un ArgumentOutOfRangeException eccezione se l'esempio tenta di visualizzare i sette elementi nella raccolta prima che la raccolta è completamente popolata.

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 questo caso, due risorse sono accessibili da più thread:

  • Raccolta continents. Il List<T>.Add viene chiamato da più thread. Inoltre, il thread principale o primario si presuppone che la raccolta è completamente popolata con sette elementi quando si esegue l'iterazione sui relativi membri.

  • Il msg stringa, che è concatenato da più thread.

Per correggere l'errore, verificare che lo stato condiviso avviene in modo thread-safe, come indicato di seguito.

  • Se l'applicazione utilizza un oggetto array o raccolta, è consigliabile utilizzare una classe di raccolta thread-safe, ad esempio i tipi nel System.Collections.Concurrent dello spazio dei nomi o System.Collections.Immutable versione out-of-band.

  • Verificare che lo stato condiviso (vale a dire risorse che sono accessibili da più thread) si accede in modo thread-safe, in modo che un solo thread alla volta dispone dell'accesso esclusivo alle risorse. Un numero elevato di classi, ad esempio CountdownEvent, Interlocked, Monitor, e Mutex, sono disponibili per sincronizzare l'accesso alle risorse. Per altre informazioni, vedere Managed Threading. Inoltre, supporto di lingue è disponibile tramite il blocco istruzione in c# e SyncLock costrutto in Visual Basic.

Gli indirizzi di esempio seguente il ArgumentOutOfRangeException (eccezione) e gli altri problemi dell'esempio precedente. Sostituisce il List<T> dell'oggetto con un ConcurrentBag<T> oggetto per garantire che l'accesso alla raccolta è thread-safe, utilizza un CountdownEvent oggetto per assicurarsi che il thread dell'applicazione continui solo dopo che è eseguite altri thread, e viene utilizzato un blocco per garantire che solo un thread può accedere il msg variabile alla volta.

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 utilizza HRESULT COR_E_ARGUMENTOUTOFRANGE, con valore 0x80131502.

Per un elenco di valori di proprietà iniziali per un'istanza di ArgumentOutOfRangeException, vedere il ArgumentOutOfRangeException costruttori.

Nell'esempio seguente viene definita una classe per includere informazioni su un ospite invitato. Se l'utente guest è meno di 21 anni un ArgumentOutOfRangeException viene generata un'eccezione.

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
Disponibile da 8
.NET Framework
Disponibile da 1.1
Libreria di classi portabile
Supportato in: piattaforme .NET portabili
Silverlight
Disponibile da 2.0
Windows Phone Silverlight
Disponibile da 7.0
Windows Phone
Disponibile da 8.1

I membri statici pubblici ( Condiviso in Visual Basic) di questo tipo è thread safe. Non tutti i membri di istanza sono garantiti come thread safe.

Torna all'inizio
Mostra: