ArgumentException Classe

Definição

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

Herança

Object

Exception

ArgumentException

Herança

Object

Exception

SystemException

ArgumentException

Derivado

System.ArgumentNullException

System.ArgumentOutOfRangeException

System.ComponentModel.InvalidAsynchronousStateException

System.ComponentModel.InvalidEnumArgumentException

System.DuplicateWaitObjectException

Mais…

Atributos

SerializableAttribute ComVisibleAttribute

Implementações

ISerializable

Exemplos

O exemplo a seguir demonstra como lançar e capturar um ArgumentException. Ele usa ArgumentException.GetType(). Propriedade Name para exibir o nome do objeto de exceção e também usa a Message propriedade para exibir o texto da mensagem de exceção.

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

Comentários

ArgumentException é gerado quando um método é invocado e pelo menos um dos argumentos passados não atende à especificação de parâmetro do método chamado. A ParamName propriedade identifica o argumento inválido.

Mais comumente, um ArgumentException é gerado pelo Common Language Runtime ou outra biblioteca de classes e indica o erro do desenvolvedor. Se você lançar um ArgumentException do código, deverá garantir que a propriedade da Message exceção inclua uma mensagem de erro significativa que descreva o argumento inválido e o intervalo esperado de valores para o argumento.

As classes derivadas primárias de ArgumentException são ArgumentNullException e ArgumentOutOfRangeException. Essas classes derivadas devem ser usadas em vez de ArgumentException, exceto em situações em que nenhuma das classes derivadas é aceitável. Por exemplo, as exceções devem ser geradas por:

• ArgumentNullException sempre que null é passado para um método que não o aceita como um argumento válido.

• ArgumentOutOfRangeException quando o valor de um argumento está fora do intervalo de valores aceitáveis; por exemplo, quando o valor "46" é passado como o argumento de mês durante a criação de um DateTime.

Se a chamada de método não tiver nenhum argumento ou se a falha não envolver os argumentos em si, deverá InvalidOperationException ser usada.

ArgumentException usa o COR_E_ARGUMENT HRESULT, que tem o valor 0x80070057.

Para obter uma lista de valores de propriedade inicial para uma instância do ArgumentException, consulte o ArgumentException construtores.

Em F#, você pode usar a função invalidArg para gerar e gerar um ArgumentException.

Construtores

Propriedades

Métodos

Eventos

Aplica-se a

Confira também

• Exception
• Manipulando e lançando exceções