ArgumentException Classe

Definizione

Spazio dei nomi:

System

Assembly:

System.Runtime.dll

Origine:

ArgumentException.cs

L'eccezione generata quando uno degli argomenti forniti a un metodo non è valido.

public ref class ArgumentException : SystemException

public class ArgumentException : SystemException

type ArgumentException = class
    inherit SystemException

Public Class ArgumentException
Inherits SystemException

Ereditarietà

Object

Exception

SystemException

ArgumentException

Derivato

System.ArgumentNullException

System.ArgumentOutOfRangeException

System.ComponentModel.InvalidAsynchronousStateException

System.ComponentModel.InvalidEnumArgumentException

System.DuplicateWaitObjectException

System.Globalization.CultureNotFoundException

System.IO.Log.ReservationNotFoundException

System.Text.DecoderFallbackException

System.Text.EncoderFallbackException

System.Text.RegularExpressions.RegexParseException

Esempio

Nell'esempio seguente viene illustrato come generare e rilevare un ArgumentExceptionoggetto . Usa ArgumentException.GetType(). Proprietà Name per visualizzare il nome dell'oggetto eccezione e usa anche la Message proprietà per visualizzare il testo del messaggio di eccezione.

using namespace System;

static int DivideByTwo(int num) 
{
    // If num is an odd number, throw an ArgumentException.
    if ((num & 1) == 1)
        throw gcnew ArgumentException(String::Format("{0} is not an even number", num), 
                                      "num");

    // num is even, return half of its value.
    return num / 2;
}

void main() 
{
    // Define some integers for a division operation.
    array<int>^ values = { 10, 7 };
    for each (int value in values) {
        try {
           Console::WriteLine("{0} divided by 2 is {1}", value, DivideByTwo(value));
        }
        catch (ArgumentException^ e) {
           Console::WriteLine("{0}: {1}", e->GetType()->Name, e->Message);
        }
        Console::WriteLine();
    }
}
// This example displays the following output:
//     10 divided by 2 is 5
//     
//     ArgumentException: 7 is not an even number
//     Parameter name: num

using System;

public class Example
{
    static void Main()
    {
        // Define some integers for a division operation.
        int[] values = { 10, 7 };
        foreach (var value in values) {
            try {
               Console.WriteLine("{0} divided by 2 is {1}", value, DivideByTwo(value));
            }
            catch (ArgumentException e) {
               Console.WriteLine("{0}: {1}", e.GetType().Name, e.Message);
            }
            Console.WriteLine();
        }
    }

    static int DivideByTwo(int num)
    {
        // If num is an odd number, throw an ArgumentException.
        if ((num & 1) == 1)
            throw new ArgumentException(String.Format("{0} is not an even number", num),
                                      "num");

        // num is even, return half of its value.
        return num / 2;
    }
}
// This example displays the following output:
//     10 divided by 2 is 5
//
//     ArgumentException: 7 is not an even number
//     Parameter name: num

open System

let divideByTwo num =
    // If num is an odd number, throw an ArgumentException.
    if num % 2 = 1 then
        invalidArg "num" $"{num} is not an even number"

    // num is even, return half of its value.
    num / 2;

// Define some integers for a division operation.
let values = [ 10; 7 ]
for value in values do
    try 
        printfn $"{value} divided by 2 is {divideByTwo value}"
    with
    | :? ArgumentException as e ->
        printfn $"{e.GetType().Name}: {e.Message}"
    
    printfn ""

// This example displays the following output:
//     10 divided by 2 is 5
//
//     ArgumentException: 7 is not an even number (Parameter 'num')

Public Class Example
    Public Shared Sub Main()
        ' Define some integers for a division operation.
        Dim values() As Integer = { 10, 7 }

        For Each value In values
            Try 
               Console.WriteLine("{0} divided by 2 is {1}", value, DivideByTwo(value))
            Catch e As ArgumentException
               Console.WriteLine("{0}: {1}", e.GetType().Name, e.Message)
            End Try
            Console.WriteLine()
        Next
    End Sub
    
    Private Shared Function DivideByTwo(ByVal num As Integer) As Integer
        ' If num is an odd number, throw an ArgumentException.
        If (num And 1) = 1 Then
            Throw New ArgumentException(String.Format("{0} is not an even number", num), 
                                      "num")
        End If
        Return num \ 2
    End Function
End Class
' The example displays the following output:
'     10 divided by 2 is 5
'     
'     ArgumentException: 7 is not an even number
'     Parameter name: num

Commenti

ArgumentException viene generato quando viene richiamato un metodo e almeno uno degli argomenti passati non soddisfa la specifica del parametro del metodo denominato. La ParamName proprietà identifica l'argomento non valido.

In genere, un oggetto ArgumentException viene generato da Common Language Runtime o da un'altra libreria di classi e indica l'errore dello sviluppatore. Se si genera un ArgumentException oggetto dal codice, è necessario assicurarsi che la proprietà dell'eccezione Message includa un messaggio di errore significativo che descrive l'argomento non valido e l'intervallo previsto di valori per l'argomento.

Le classi derivate principali di ArgumentException sono ArgumentNullException e ArgumentOutOfRangeException. Queste classi derivate devono essere usate invece di ArgumentException, tranne in situazioni in cui nessuna delle classi derivate è accettabile. Ad esempio, le eccezioni devono essere generate da:

• ArgumentNullException ogni volta null che viene passato a un metodo che non lo accetta come argomento valido.

• ArgumentOutOfRangeException quando il valore di un argomento non è compreso nell'intervallo di valori accettabili; ad esempio, quando il valore "46" viene passato come argomento mese durante la creazione di un DateTimeoggetto .

Se la chiamata al metodo non ha alcun argomento o se l'errore non implica gli argomenti stessi, InvalidOperationException deve essere usato.

ArgumentException usa il COR_E_ARGUMENT HRESULT, che ha il valore 0x80070057.

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

In F#, è possibile usare la funzione invalidArg per generare e generare un'eccezione ArgumentException.

Costruttori

ArgumentException()	Inizializza una nuova istanza della classe ArgumentException.
ArgumentException(SerializationInfo, StreamingContext)	Obsoleti. Inizializza una nuova istanza della classe ArgumentException con dati serializzati.
ArgumentException(String)	Inizializza una nuova istanza della classe ArgumentException con un messaggio di errore specificato.
ArgumentException(String, Exception)	Inizializza una nuova istanza della classe ArgumentException con un messaggio di errore specificato e un riferimento all'eccezione interna che è la causa dell'eccezione corrente.
ArgumentException(String, String)	Inizializza una nuova istanza della classe ArgumentException con un messaggio di errore specificato e il nome del parametro che genera questa eccezione.
ArgumentException(String, String, Exception)	Inizializza una nuova istanza della classe ArgumentException con un messaggio di errore specificato, il nome del parametro e un riferimento all'eccezione interna che è la causa dell'eccezione corrente.

Proprietà

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 il nome del parametro o, se non è stato impostato alcun nome di parametro, soltanto il messaggio di errore.
ParamName	Ottiene il nome del parametro che ha causato questa eccezione.
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 nome del parametro e 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)
ThrowIfNullOrEmpty(String, String)	Genera un'eccezione se argument è null o vuota.
ThrowIfNullOrWhiteSpace(String, String)	Genera un'eccezione se argument è null, vuota o è costituita solo da caratteri di spazio vuoto.
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)

Vedi anche

• Exception
• Gestione e generazione di eccezioni