ArgumentOutOfRangeException Classe

Definizione

Spazio dei nomi:

System

Assembly:

System.Runtime.dll

Origine:

ArgumentOutOfRangeException.cs

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

C#

public class ArgumentOutOfRangeException : ArgumentException

Ereditarietà

Object

Exception

SystemException

ArgumentException

ArgumentOutOfRangeException

Esempio

Nell'esempio seguente viene definita una classe che contiene informazioni su un guest invitato. Se il guest è minore di 21, viene generata un'eccezione ArgumentOutOfRangeException .

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

Commenti

Viene ArgumentOutOfRangeException generata un'eccezione 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 previsto per l'argomento. La ParamName proprietà identifica l'argomento non valido e la ActualValue proprietà, se è presente un valore, identifica il valore non valido.

In genere, si verifica un ArgumentOutOfRangeException errore dello sviluppatore. Anziché gestire l'eccezione in un try/catch blocco, è necessario eliminare la causa dell'eccezione o, se l'argomento viene restituito da una chiamata al metodo o dall'input dell'utente prima di essere passato al metodo che genera l'eccezione, è necessario convalidare gli argomenti prima di passarli al metodo .

ArgumentOutOfRangeException viene usato ampiamente da:

• Classi negli spazi dei System.Collections nomi e System.IO .

• Classe Array.

• Metodi di manipolazione delle stringhe nella String classe .

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

• Si sta recuperando il membro di una raccolta in base al numero di indice e il numero di indice non è valido.

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

  1. La raccolta non ha membri e il codice presuppone che lo faccia. Nell'esempio seguente viene eseguito un tentativo di recuperare il primo elemento di una raccolta senza elementi:

     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
     

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

     C#

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

  2. In alcuni casi, l'eccezione può verificarsi perché si sta tentando di aggiungere un membro a una raccolta usando un indice che non esiste, anziché chiamando il metodo , ad esempio Add, esistente a questo scopo. Nell'esempio seguente viene tentato di aggiungere un elemento a una raccolta utilizzando un indice inesistente anziché chiamare il List<T>.Add metodo .

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

     Il frammento di codice seguente corregge questo errore:

     C#

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

  3. Si sta tentando di recuperare un elemento il cui indice è negativo. Ciò si verifica in genere perché è stata eseguita una ricerca in una raccolta per l'indice di un particolare elemento e si presuppone erroneamente che la ricerca abbia esito positivo. Nell'esempio seguente la chiamata al List<T>.FindIndex(Predicate<T>) metodo non riesce a trovare una stringa uguale a "Z" e quindi restituisce -1. Tuttavia, si tratta di un valore di indice non valido.

     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
     

     Per evitare l'eccezione, verificare che la ricerca abbia esito positivo assicurandosi che l'indice restituito sia maggiore o uguale a zero prima di tentare di recuperare l'elemento dalla raccolta, come avviene nel frammento di codice seguente.

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

     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
     

     Poiché le raccolte in .NET usano l'indicizzazione in base zero, il primo elemento della raccolta è in corrispondenza dell'indice 0 e l'ultimo elemento è in corrispondenza dell'indice Count - 1. È possibile eliminare l'errore assicurandosi di accedere all'ultimo elemento in corrispondenza dell'indice Count - 1, come avviene nel codice seguente.

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

• Si sta tentando di eseguire un'operazione di stringa chiamando un metodo di manipolazione delle stringhe e l'indice iniziale non esiste nella stringa.

  Overload di metodi come String.Compare, , String.CompareOrdinal, String.IndexOfString.InsertIndexOfAny, String.LastIndexOf, String.LastIndexOfAny, Remove, o String.Substring che consentono di specificare l'indice iniziale dell'operazione richiede che l'indice sia una posizione valida all'interno della stringa. Gli indici validi sono compreso tra 0 e String.Length 1.

  Esistono quattro cause comuni di questa ArgumentOutOfRangeException eccezione:

  1. Si sta usando una stringa vuota o String.Empty. Poiché la relativa String.Length proprietà restituisce 0, qualsiasi tentativo di modificarlo in base all'indice genera un'eccezione ArgumentOutOfRangeException . Nell'esempio seguente viene definito un GetFirstCharacter metodo che restituisce il primo carattere di una stringa. Se la stringa è vuota, poiché la stringa finale passata al metodo è , il metodo genera un'eccezione 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()
     

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

     C#

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

  2. Si sta modificando una stringa in base alla posizione di una sottostringa all'interno di tale stringa e non è stato possibile determinare se la sottostringa è stata effettivamente trovata.

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

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

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

     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. Si è tentato di estrarre una sottostringa esterna all'intervallo della stringa corrente.

     I metodi che estraggono tutte le sottostringhe richiedono di specificare la posizione iniziale della sottostringa e, per le sottostringhe che non continuano alla fine della stringa, il numero di caratteri nella sottostringa. Si noti che questo non è l'indice dell'ultimo carattere nella sottostringa.

     In ArgumentOutOfRangeException questo caso viene generata un'eccezione perché il numero di caratteri nella sottostringa è stato calcolato in modo non corretto. Se si usa un metodo di ricerca come String.IndexOf per identificare le posizioni iniziale e finale di una sottostringa:

     • Se il carattere nella posizione finale restituita da String.IndexOf deve essere incluso nella sottostringa, la posizione finale della sottostringa viene assegnata dalla formula

       endIndex - startIndex + 1
       

     • Se il carattere nella posizione finale restituita da String.IndexOf deve essere escluso dalla sottostringa, la posizione finale della sottostringa viene assegnata dalla formula

       endIndex - startIndex
       

       Nell'esempio seguente viene definito un FindWords metodo che usa il String.IndexOfAny(Char[], Int32) metodo per identificare caratteri di spazio e segni di punteggiatura in una stringa e restituisce una matrice contenente le parole trovate nella stringa.

       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'
       

• È stato passato un numero negativo a un metodo con un argomento che richiede solo numeri positivi e zero oppure è 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 richiede di 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. Tuttavia, poiché l'argomento dimensione nell'esempio seguente ha un valore negativo, il metodo genera un'eccezione 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
  

  Per correggere l'errore, verificare che il valore dell'argomento non valido sia non negativo. È possibile eseguire questa operazione specificando un valore valido, poiché il frammento di codice seguente esegue.

  C#

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

  È anche possibile convalidare l'input e, se non è valido, eseguire alcune azioni. Il frammento di codice seguente visualizza un messaggio di errore anziché chiamare il metodo.

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

• Una condizione di razza esiste in un'app che è multithreading o ha attività che eseguono in modo asincrono e che aggiorna una matrice o una raccolta.

  Nell'esempio seguente viene usato un oggetto per popolare una List<T> raccolta di Continent oggetti. Genera un valore ArgumentOutOfRangeException se l'esempio tenta di visualizzare i sette elementi della raccolta prima che l'insieme sia completamente popolato.

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

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

  • Stringa msg concatenata da più thread.

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

  • se l'app usa una matrice o un oggetto raccolta, prendere in considerazione l'uso di una classe di raccolta thread-safe, ad esempio i tipi nello System.Collections.Concurrent spazio dei nomi o nella System.Collections.Immutable versione out-of-band.

  • Assicurarsi che lo stato condiviso (ovvero le risorse a cui è possibile accedere da più thread) sia accessibile in modo thread sicuro, in modo che un solo thread alla volta abbia accesso esclusivo alle risorse. Un numero elevato di classi, ad esempio CountdownEvent, Interlocked, Monitore , Mutexsono disponibili per sincronizzare l'accesso alle risorse. Per altre informazioni, vedere Threading. Inoltre, il supporto del linguaggio è disponibile tramite l'istruzione lock in C# e il costrutto SyncLock in Visual Basic.

  Nell'esempio seguente vengono risolti gli ArgumentOutOfRangeException altri problemi dell'esempio precedente. Sostituisce l'oggetto con un oggetto per garantire che l'accesso List<T> all'insieme sia thread-safe, usa un ConcurrentBag<T> oggetto per assicurarsi che il thread dell'applicazione continui solo dopo l'esecuzione di altri thread e usi un CountdownEvent blocco per garantire che solo un thread possa accedere alla msg variabile alla volta.

  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 usa il COR_E_ARGUMENTOUTOFRANGE HRESULT, che ha il valore 0x80131502.

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

Costruttori

ArgumentOutOfRangeException()	Inizializza una nuova istanza della classe ArgumentOutOfRangeException.
ArgumentOutOfRangeException(SerializationInfo, StreamingContext)	Obsoleti. Inizializza una nuova istanza della classe ArgumentOutOfRangeException con dati serializzati.
ArgumentOutOfRangeException(String)	Inizializza una nuova istanza della classe ArgumentOutOfRangeException con il nome del parametro che causa l'eccezione.
ArgumentOutOfRangeException(String, Exception)	Inizializza una nuova istanza della classe ArgumentOutOfRangeException con un messaggio di errore e l'eccezione che ha causato l'eccezione corrente.
ArgumentOutOfRangeException(String, Object, String)	Inizializza una nuova istanza della classe ArgumentOutOfRangeException con il nome del parametro, il valore dell'argomento e un messaggio di errore specificato.
ArgumentOutOfRangeException(String, String)	Inizializza una nuova istanza della classe ArgumentOutOfRangeException con il nome del parametro che causa l'eccezione e un messaggio di errore specificato.

Proprietà

ActualValue	Ottiene il valore dell'argomento che causa l'eccezione.
Data	Ottiene una raccolta di coppie chiave/valore che forniscono informazioni definite dall'utente aggiuntive sull'eccezione. (Ereditato da Exception)
HelpLink	Ottiene o imposta un collegamento al file della Guida associato all'eccezione. (Ereditato da Exception)
HResult	Ottiene o imposta HRESULT, un valore numerico codificato che viene assegnato a un'eccezione specifica. (Ereditato da Exception)
InnerException	Ottiene l'istanza di Exception che ha causato l'eccezione corrente. (Ereditato da Exception)
Message	Ottiene il messaggio di errore e la rappresentazione in forma di stringa del valore dell'argomento non valido, oppure solo del messaggio di errore se il valore dell'argomento è null.
ParamName	Ottiene il nome del parametro che ha causato questa eccezione. (Ereditato da ArgumentException)
Source	Ottiene o imposta il nome dell'oggetto o dell'applicazione che ha generato l'errore. (Ereditato da Exception)
StackTrace	Ottiene una rappresentazione di stringa dei frame immediati nello stack di chiamate. (Ereditato da Exception)
TargetSite	Ottiene il metodo che genera l'eccezione corrente. (Ereditato da Exception)

Metodi

Equals(Object)	Determina se l'oggetto specificato è uguale all'oggetto corrente. (Ereditato da Object)
GetBaseException()	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)
GetHashCode()	Funge da funzione hash predefinita. (Ereditato da Object)
GetObjectData(SerializationInfo, StreamingContext)	Obsoleti. Imposta l'oggetto SerializationInfo con il valore dell'argomento non valido e le informazioni aggiuntive sull'eccezione.
GetType()	Ottiene il tipo di runtime dell'istanza corrente. (Ereditato da Exception)
MemberwiseClone()	Crea una copia superficiale dell'oggetto Object corrente. (Ereditato da Object)
ThrowIfEqual<T>(T, T, String)	Genera un'eccezione ArgumentOutOfRangeException se value è uguale a other.
ThrowIfGreaterThan<T>(T, T, String)	Genera un'eccezione ArgumentOutOfRangeException se value è maggiore di other.
ThrowIfGreaterThanOrEqual<T>(T, T, String)	Genera un'eccezione ArgumentOutOfRangeException se value è maggiore o uguale a other.
ThrowIfLessThan<T>(T, T, String)	Genera un'eccezione ArgumentOutOfRangeException se value è minore di other.
ThrowIfLessThanOrEqual<T>(T, T, String)	Genera un'eccezione ArgumentOutOfRangeException se value è minore o uguale a other.
ThrowIfNegative<T>(T, String)	Genera un'eccezione ArgumentOutOfRangeException se value è negativa.
ThrowIfNegativeOrZero<T>(T, String)	Genera un'eccezione ArgumentOutOfRangeException se value è negativa o zero.
ThrowIfNotEqual<T>(T, T, String)	Genera un'eccezione ArgumentOutOfRangeException se value non è uguale a other.
ThrowIfZero<T>(T, String)	Genera un'eccezione ArgumentOutOfRangeException se value è zero.
ToString()	Crea e restituisce una rappresentazione di stringa dell'eccezione corrente. (Ereditato da Exception)

Eventi

SerializeObjectState

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

Si applica a

Vedi anche

• Exception