ArgumentException Classe

Definizione

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à

Object

Exception

ArgumentException

Ereditarietà

Object

Exception

SystemException

ArgumentException

Derivato

System.ArgumentNullException

System.ArgumentOutOfRangeException

System.ComponentModel.InvalidAsynchronousStateException

System.ComponentModel.InvalidEnumArgumentException

System.DuplicateWaitObjectException

Altro…

Attributi

SerializableAttribute ComVisibleAttribute

Implementazioni

ISerializable

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

Proprietà

Metodi

Eventi

Si applica a

Vedi anche

• Exception
• Gestione e generazione di eccezioni