ArgumentException Classe

Definizione

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

public ref class ArgumentException : Exception
public ref class ArgumentException : SystemException
public class ArgumentException : Exception
public class ArgumentException : SystemException
[System.Serializable]
public class ArgumentException : SystemException
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public class ArgumentException : SystemException
type ArgumentException = class
    inherit Exception
type ArgumentException = class
    inherit SystemException
type ArgumentException = class
    inherit SystemException
    interface ISerializable
[<System.Serializable>]
type ArgumentException = class
    inherit SystemException
    interface ISerializable
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type ArgumentException = class
    inherit SystemException
    interface ISerializable
Public Class ArgumentException
Inherits Exception
Public Class ArgumentException
Inherits SystemException
Ereditarietà
ArgumentException
Ereditarietà
ArgumentException
Derivato
Attributi
Implementazioni

Esempio

Nell'esempio seguente viene illustrato come generare e intercettare un oggetto ArgumentException . Usa ArgumentException.GetType(). Proprietà Name per visualizzare il nome dell'oggetto eccezione e usa anche la proprietà per Message 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
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 generata quando viene richiamato un metodo e almeno uno degli argomenti passati non soddisfa la specifica del parametro del metodo chiamato. La ParamName proprietà identifica l'argomento non valido.

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

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

  • ArgumentNullException ogni null volta 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 month durante la creazione di un oggetto DateTime .

Se la chiamata al metodo non ha argomenti o se l'errore non interessa gli argomenti stessi, InvalidOperationException è necessario usare .

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

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

Costruttori

ArgumentException()

Inizializza una nuova istanza della classe ArgumentException.

ArgumentException(SerializationInfo, StreamingContext)

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)

Imposta l'oggetto SerializationInfo con il nome del parametro e informazioni aggiuntive sull'eccezione.

GetObjectData(SerializationInfo, StreamingContext)

Quando ne viene eseguito l'override in una classe derivata, imposta il controllo SerializationInfo con le informazioni sull'eccezione.

(Ereditato da Exception)
GetType()

Ottiene il tipo di runtime dell'istanza corrente.

(Ereditato da Exception)
MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.

(Ereditato da Object)
ToString()

Crea e restituisce una rappresentazione di stringa dell'eccezione corrente.

(Ereditato da Exception)

Eventi

SerializeObjectState
Obsoleta.

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