ArgumentException Clase

Definición

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

Herencia

Object

Exception

ArgumentException

Herencia

Object

Exception

SystemException

ArgumentException

Derivado

System.ArgumentNullException

System.ArgumentOutOfRangeException

System.ComponentModel.InvalidAsynchronousStateException

System.ComponentModel.InvalidEnumArgumentException

System.DuplicateWaitObjectException

Más…

Atributos

SerializableAttribute ComVisibleAttribute

Implementaciones

ISerializable

Ejemplos

En el ejemplo siguiente se muestra cómo iniciar y capturar un .ArgumentException Usa ArgumentException.GetType(). Propiedad Name para mostrar el nombre del objeto de excepción y también usa la Message propiedad para mostrar el texto del mensaje de excepción.

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

Comentarios

ArgumentException se produce cuando se invoca un método y al menos uno de los argumentos pasados no cumple la especificación de parámetros del método llamado. La ParamName propiedad identifica el argumento no válido.

Normalmente, Common Language Runtime u otra biblioteca de clases inician una ArgumentException excepción e indican el error del desarrollador. Si inicia un ArgumentException desde el código, debe asegurarse de que la propiedad de Message la excepción incluya un mensaje de error significativo que describa el argumento no válido y el intervalo esperado de valores para el argumento.

Las clases derivadas principales de ArgumentException son ArgumentNullException y ArgumentOutOfRangeException. Estas clases derivadas deben usarse en lugar de ArgumentException, excepto en situaciones en las que ninguna de las clases derivadas es aceptable. Por ejemplo, las excepciones se deben producir mediante:

• ArgumentNullException siempre que null se pasa a un método que no lo acepta como argumento válido.

• ArgumentOutOfRangeException cuando el valor de un argumento está fuera del intervalo de valores aceptables; por ejemplo, cuando el valor "46" se pasa como argumento month durante la creación de un DateTime.

Si la llamada al método no tiene ningún argumento o si el error no implica los propios argumentos, InvalidOperationException se debe usar.

ArgumentException usa el COR_E_ARGUMENT HRESULT, que tiene el valor 0x80070057.

Para obtener una lista de valores de propiedad iniciales de una instancia de ArgumentException, consulte el ArgumentException constructores.

En F#, puede usar la función invalidArg para generar y generar una excepción ArgumentException.

Constructores

Propiedades

Métodos

Eventos

Se aplica a

Consulte también

• Exception
• Controlar y generar excepciones