Tipos de excepciones lanzadas para argumentos o parámetros no válidos en C#
-
Lanzar
ArgumentExceptionpara parámetros no válidos o inesperados enC# -
Lanzar
ArgumentNullExceptionpara parámetros no válidos o inesperados enC# -
Lanzar
ArgumentOutOfRangeExceptionpara parámetros no válidos o inesperados enC# -
Cree una excepción definida por el usuario para parámetros no válidos o inesperados en
C#
Las excepciones proporcionan información sobre un error de tiempo de ejecución en un programa de C# o una condición que no se espera que ocurra o que infringe una restricción del sistema/aplicación. En este tutorial, aprenderá tres excepciones diferentes relacionadas con argumentos o parámetros no válidos y cómo incluirlos en un programa C#.
Definir un bloque de código que lanza una excepción cuando detecta un argumento o parámetro no válido es la forma más fácil de manejar errores inesperados. El código incorrecto o la entrada del usuario pueden causar errores y su detección requiere una excepción generada por el código de la aplicación C# o el tiempo de ejecución.
Lanzar ArgumentException para parámetros no válidos o inesperados en C#
La ArgumentException se lanza cuando un método recibe un argumento no válido. Utiliza la propiedad ArgumentException.GetType().Name para mostrar el nombre del objeto de excepción.
Con la propiedad Message, puede mostrar el texto del mensaje de excepción, que contiene el motivo de su aparición. Es importante que siempre que lance excepciones en C#, la propiedad Message de esa excepción debe contener un mensaje significativo para describir el argumento no válido y el rango esperado de valores del argumento.
La ArgumentNullException y ArgumentOutOfRangeException son las clases derivadas de la clase ArgumentException. La propia clase ArgumentException hereda de la clase System.SystemException.
En general, System.Exception es una clase base de cada excepción lanzada por argumentos o parámetros no válidos en C#.
using System;
namespace ArgumentExceptionExp {
class UserEnrollment {
static void Main(string[] args) {
Console.WriteLine("Please enter your first name and last name for enrollment.");
Console.WriteLine("First Name: ");
var userFirstN = Console.ReadLine();
Console.WriteLine("Last Name: ");
var userLastN = Console.ReadLine();
try {
var userFullN = ShowFullUserName(userFirstN, userLastN);
Console.WriteLine($"Congratulations, {userFullN}!");
} catch (ArgumentException ex) {
Console.WriteLine("Something went wrong, please try again!");
Console.WriteLine(ex);
}
}
static string ShowFullUserName(string userFirstN, string userLastN) {
if (userFirstN == "" || userLastN == "")
throw new ArgumentException(
"Attention, please! Your first or last user name cannot be empty.");
return $"{userFirstN} {userLastN}";
}
}
}
Producción :
Please enter your first name and last name for enrollment.
First Name:
Last Name:
Kazmi
Something went wrong, please try again!
System.ArgumentException: Attention, please! Your first or last user name cannot be empty.
at ArgumentExceptionExp.UserEnrollment.ShowFullUserName (System.String userFirstN, System.String userLastN) [0x00020] in <8fb4997067094d929e0f81a3893882f9>:0
at ArgumentExceptionExp.UserEnrollment.Main (System.String[] args) [0x0002f] in <8fb4997067094d929e0f81a3893882f9>:0
En este caso, la ArgumentException se lanzará solo cuando una actividad inesperada o no válida impida que un método complete su función normal. Es una buena práctica de programación agregar información a una excepción que se vuelve a generar para proporcionar más información cuando se depura.
Podemos lanzar una excepción usando la palabra clave throw seguida de una nueva instancia derivada de la clase System.Exception. El marco .NET proporciona muchos tipos de excepción estándar predefinidos que puede usar para manejar argumentos y parámetros no válidos.
Lanzar ArgumentNullException para parámetros no válidos o inesperados en C#
Cuando un método en el programa C# recibe una referencia nula que no la acepta como un argumento válido, requiere que se lance ArgumentNullException para comprender el error. Se lanza en tiempo de ejecución cuando se pasa un objeto sin instanciar a un método para evitar el error.
Además, se lanza cuando un objeto devuelto por una llamada de método se pasa como argumento a un segundo método, pero el valor del objeto devuelto original es null.
Su comportamiento es idéntico al ArgumentException; sin embargo, utiliza el HRESULT E_POINTER, que tiene el valor 0x80004003.
using System;
namespace TryCatchArgNullExcep {
class ArgNullExpProgram {
static void Main(string[] args) {
try {
var ArgNullEVariable = new ArgNullMember(null, 32);
} catch (ArgumentNullException ex) {
Console.WriteLine("Sorry for the inconvenience, something went wrong...");
Console.WriteLine(ex);
}
}
class ArgNullMember {
public ArgNullMember(string memberName, int memberAge) {
if (memberName == null)
throw new ArgumentNullException(
nameof(memberName), "The member name cannot be `null` or empty. Please, try again!");
MemberName = memberName;
MemberAge = memberAge;
}
public string MemberName { get; private set; }
public int MemberAge { get; private set; }
}
}
}
Producción :
Sorry for the inconvenience, something went wrong...
System.ArgumentNullException: The member name cannot be `null` or empty. Please, try again!
Parameter name: memberName
at TryCatchArgNullExcep.ArgNullExpProgram+ArgNullMember..ctor (System.String memberName, System.Int32 memberAge) [0x00010] in <1001b7741efd42ec97508d09c5fc60a2>:0
at TryCatchArgNullExcep.ArgNullExpProgram.Main (System.String[] args) [0x00002] in <1001b7741efd42ec97508d09c5fc60a2>:0
Lanzar ArgumentOutOfRangeException para parámetros no válidos o inesperados en C#
Esta excepción se produce cuando el valor de un argumento está fuera del rango de valores permitido definido por el método invocado en C#. En general, una ArgumentOutOfRangeException resulta del error del desarrollador.
En lugar de manejarlo en un bloque try/catch, debe eliminar la causa de la excepción o validar los argumentos antes de pasarlos al método.
Las clases lo utilizan ampliamente en los espacios de nombres System.Collections y System.IO, la clase de matriz y los métodos de manipulación de cadenas en la clase String. Lo lanza CLR u otra biblioteca de clases en C# e indica un error del desarrollador.
using System;
namespace ArgumentOutOfRangeExceptionExp {
class userInfo {
static void Main(string[] args) {
try {
Console.WriteLine("Enter User Name: ");
string Hassan = Console.ReadLine();
Console.WriteLine("Enter your Age: ");
int ageU = Int32.Parse(Console.ReadLine());
var user = new userInfoProcess(Hassan, ageU);
} catch (ArgumentOutOfRangeException ex) {
Console.WriteLine("Please be patient, something went wrong.");
Console.WriteLine(ex);
}
}
}
class userInfoProcess {
public userInfoProcess(string userName, int userAge) {
if (userName == null) {
throw new ArgumentOutOfRangeException(nameof(userName),
"Your username is invalid, please try again!");
} else if (userName == "") {
throw new ArgumentOutOfRangeException(nameof(userName),
"Your username is invalid, please try again!");
}
if (userAge < 18 || userAge > 50)
throw new ArgumentOutOfRangeException(
nameof(userAge), "Your age is outside the allowable range, please enter a valid user.");
ArgNullUName = userName;
ArgNullUAge = userAge;
}
public string ArgNullUName { get; private set; }
public int ArgNullUAge { get; private set; }
}
}
Producción :
Enter User Name:
Hassan
Enter your Age:
11
Please be patient, something went wrong.
System.ArgumentOutOfRangeException: Your age is outside the allowable range, please enter a valid user.
Parameter name: userAge
at ArgumentOutOfRangeExceptionExp.userInfoProcess..ctor (System.String userName, System.Int32 userAge) [0x00052] in <b199b92ace93448f8cc4c37cc4d5df33>:0
at ArgumentOutOfRangeExceptionExp.userInfo.Main (System.String[] args) [0x00029] in <b199b92ace93448f8cc4c37cc4d5df33>:0
Cree una excepción definida por el usuario para parámetros no válidos o inesperados en C#
También puede definir sus excepciones para argumentos o parámetros no válidos en C#. Las clases de excepción definidas por el usuario se derivan de la clase Exception.
El manejo de excepciones en C#, respaldado por el bloque try/catch y finally, es un mecanismo para detectar y manejar errores de código en tiempo de ejecución.
using System;
namespace UserDefinedExceptionExp {
class ExceptionHandlingC {
static void Main(string[] args) {
string Name = "Hassan";
int Age = 18;
Check temp = new Check();
try {
temp.checkTemp(Name, Age);
} catch (InvalidNameException e) {
Console.WriteLine("InvalidNameException: {0}", e.Message);
}
Console.ReadKey();
}
}
}
public class InvalidNameException : Exception {
public InvalidNameException(string message) : base(message) {}
}
public class Check {
public void checkTemp(string name, int age) {
// this exception will be thrown if the user name will be `Hassan`
if (name == "Hassan") {
throw(new InvalidNameException("User is not valid."));
} else {
Console.WriteLine("You are successfully signed in with the name: {0}", name);
}
}
}
Producción :
InvalidNameException: User is not valid.
En este tutorial, aprendió tres tipos de excepciones comunes para argumentos y parámetros no válidos y cómo crear las excepciones definidas por el usuario en C#.
El truco consiste en usar y lanzar la excepción correcta que brinde detalles sobre lo que salió mal, por qué está mal y cómo solucionarlo en un programa C#.
Hassan is a Software Engineer with a well-developed set of programming skills. He uses his knowledge and writing capabilities to produce interesting-to-read technical articles.
GitHub