ArgumentException Clase

Definición

Espacio de nombres:

System

Ensamblado:

System.Runtime.dll

Source:

ArgumentException.cs

Excepción que se produce cuando no es válido uno de los argumentos proporcionados para un método.

public ref class ArgumentException : SystemException

public class ArgumentException : SystemException

type ArgumentException = class
    inherit SystemException

Public Class ArgumentException
Inherits SystemException

Herencia

Object

Exception

SystemException

ArgumentException

Derivado

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

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

ArgumentException()	Inicializa una nueva instancia de la clase ArgumentException.
ArgumentException(SerializationInfo, StreamingContext)	Obsoletos. Inicializa una nueva instancia de la clase ArgumentException con datos serializados.
ArgumentException(String)	Inicializa una nueva instancia de la clase ArgumentException con el mensaje de error especificado.
ArgumentException(String, Exception)	Inicializa una nueva instancia de la clase ArgumentException con el mensaje de error especificado y una referencia a la excepción interna que representa la causa de esta excepción.
ArgumentException(String, String)	Inicializa una nueva instancia de la clase ArgumentException con un mensaje de error especificado y el nombre del parámetro que provoca esta excepción.
ArgumentException(String, String, Exception)	Inicializa una nueva instancia de la clase ArgumentException con un mensaje de error especificado, el nombre del parámetro y una referencia a la excepción interna que representa la causa de esta excepción.

Propiedades

Data	Obtiene una colección de pares clave/valor que proporciona información definida por el usuario adicional sobre la excepción. (Heredado de Exception)
HelpLink	Obtiene o establece un vínculo al archivo de ayuda asociado a esta excepción. (Heredado de Exception)
HResult	Obtiene o establece HRESULT, un valor numérico codificado que se asigna a una excepción específica. (Heredado de Exception)
InnerException	Obtiene la instancia Exception que produjo la excepción actual. (Heredado de Exception)
Message	Obtiene el mensaje de error y el nombre del parámetro. Si no se estableció ningún nombre de parámetro, obtiene solo el mensaje de error.
ParamName	Obtiene el nombre del parámetro que causa esta excepción.
Source	Devuelve o establece el nombre de la aplicación o del objeto que generó el error. (Heredado de Exception)
StackTrace	Obtiene una representación de cadena de los marcos inmediatos en la pila de llamadas. (Heredado de Exception)
TargetSite	Obtiene el método que produjo la excepción actual. (Heredado de Exception)

Métodos

Equals(Object)	Determina si el objeto especificado es igual que el objeto actual. (Heredado de Object)
GetBaseException()	Cuando se invalida en una clase derivada, devuelve la clase Exception que representa la causa principal de una o más excepciones posteriores. (Heredado de Exception)
GetHashCode()	Sirve como la función hash predeterminada. (Heredado de Object)
GetObjectData(SerializationInfo, StreamingContext)	Obsoletos. Establece el objeto SerializationInfo con el nombre del parámetro y la información adicional de la excepción.
GetType()	Obtiene el tipo de tiempo de ejecución de la instancia actual. (Heredado de Exception)
MemberwiseClone()	Crea una copia superficial del Object actual. (Heredado de Object)
ThrowIfNullOrEmpty(String, String)	Produce una excepción si argument está null o está vacía.
ThrowIfNullOrWhiteSpace(String, String)	Produce una excepción si argument es null, está vacía o solo consta de caracteres de espacio en blanco.
ToString()	Crea y devuelve una representación de cadena de la excepción actual. (Heredado de Exception)

Eventos

SerializeObjectState

Obsoletos. Ocurre cuando una excepción se serializa para crear un objeto de estado de excepción que contenga datos serializados sobre la excepción. (Heredado de Exception)

Consulte también

• Exception
• Controlar y generar excepciones