Lancer des types d'exception standard dans .NET
Le code de l'application doit différencier les exceptions causées par des arguments null / non-null. Cet article vous montre comment déclencher de telles exceptions.
Les exceptions peuvent être levées par le code du moteur d'exécution ou de l'application. Cela peut être dû à un code incorrect ou à une entrée utilisateur incorrecte qui n'a pas été prise en compte dans le code de l'application. Lorsque l'une de ces erreurs se produit, le système intercepte l'erreur et déclenche une exception.
Le processus de génération et de signalisation de l'erreur est appelé "levée d'une exception". Cette opération est effectuée à l'aide du mot clé throw
suivi d'un nouvel exemple d'une classe dérivée de System.Exception
. Il existe des types d'exception standard fournis par le framework .NET que vous pouvez utiliser plutôt que de créer une exception personnalisée.
Dans cet article, je vais vous montrer comment utiliser les ArgumentNullException
et ArgumentOutOfRangeException.
Types, qui font partie des exceptions standard du cadre.
Exception ArgumentOutOfRangeException
L'exception ArgumentOutOfRangeException
peut être levée lorsque l'argument transmis à une méthode n'est pas [1945966]. et contient une valeur qui ne fait pas partie de l'ensemble des valeurs attendues. Ce type d'exception a les propriétés ParamName et ActualValue qui nous aident à comprendre la cause de l'exception. La propriété ParamName
identifie le nom du paramètre de l'argument non valide et la propriété ActualValue
identifie la valeur non valide si une valeur est présente.
L'exception ArgumentOutOfRangeException
résulterait normalement d'une erreur de développeur et si la valeur de l'argument est renvoyée par un appel de méthode ou une entrée de l'utilisateur avant d'être transmise à la méthode qui lève l'exception, vous devez valider les arguments avant de les transmettre à la méthode.
Regardons un exemple.
espace de nom MyApp
{
en utilisant le système;
programme de classe
{
static void Main (string [] args)
{
essayer
{
Console.WriteLine ("Entrez le nom du compte");
var name = Console.ReadLine ();
Console.WriteLine ("Entrez le solde d'ouverture");
var balance = Convert.ToInt32 (Console.ReadLine ());
Console.WriteLine ("Ouvrir un compte pour {0} ... n", nom);
compte var = nouveau compte (nom, solde);
Console.WriteLine ("Compte ouvert pour {0}", account.Name);
}
catch (ArgumentOutOfRangeException ex)
{
Console.WriteLine (ex);
}
}
}
compte de classe
{
Compte public (nom de chaîne, balance int)
{
si (solde <500)
jette une nouvelle exception ArgumentOutOfRangeException (
nom de (solde),
équilibre,
"Le solde du compte ne peut pas être inférieur à 500");
Nom = nom;
Solde = solde;
}
chaîne publique Nom {get; ensemble privé; }
public int Balance {get; ensemble privé; }
}
}
Dans le code ci-dessus, nous avons une classe Account
avec les propriétés Nom
et Balance
et un constructeur qui accepte nom
et balance
en tant que paramètres. Lorsque ce constructeur obtient un solde
inférieur à 500
il lance une exception ArgumentOutOfRangeException
avec le nom du paramètre qui a provoqué l'exception, la valeur de l'argument, et un message expliquant la cause de l'erreur. Dans la méthode statique Main
nous recueillons le nom et le solde de l'utilisateur, puis créons un objet Compte
avec cette information.
Si nous exécutons l'application et si nous entrons une valeur inférieure que 500 pour le solde, nous aurons une exception. Les informations ci-dessous correspondent à ce que nous obtenons lorsque nous exécutons le code avec le solde 300.
Entrez le nom du compte.
Géant
Entrez le solde d'ouverture
300
Compte d'ouverture pour Jumbo ...
System.ArgumentOutOfRangeException: le solde du compte ne peut pas être inférieur à 500.
Nom du paramètre: balance
La valeur réelle était 300.
Throwing ArgumentNullException
Il est utile de faire la distinction entre les exceptions causées par des arguments nuls et les exceptions causées par des arguments non nuls. Le type d'exception ArgumentNullException
dérive de la classe ArgumentException
et est utilisé pour identifier les exceptions causées par des arguments nuls. Cette exception est levée lorsqu'une valeur null est passée à un argument de méthode et que null n'est pas autorisé pour cet argument.
Le code ci-dessous est un exemple d'utilisation de ce type d'exception.
using System;
espace de noms MyApp
{
programme de classe
{
static void Main (string [] args)
{
essayer
{
var utilisateur = nouvel utilisateur (null, 23);
}
catch (ArgumentNullException ex)
{
Console.WriteLine (ex);
}
}
}
classe utilisateur
{
utilisateur public (chaîne userName, int age)
{
if (userName == null)
jette une nouvelle exception ArgumentNullException (
nom de (nom d'utilisateur),
"nom d'utilisateur invalide");
Nom d'utilisateur = Nom d'utilisateur;
Age = age;
}
chaîne publique UserName {get; ensemble privé; }
public int Age {get; ensemble privé; }
}
}
Nous avons déclaré ici une classe User
avec les propriétés UserName
et Age
. Dans le constructeur de classe, nous acceptons deux paramètres et les affectons aux propriétés appropriées. Avant l'affectation, nous vérifions si userName
est null. Si c'est le cas, nous lançons une ArgumentNullException
. Nous avons appelé le constructeur de ArgumentNullException
qui accepte le nom du paramètre à l'origine de l'exception et un second paramètre représentant le message de l'exception. Vous avez peut-être remarqué que nous avons utilisé l'opérateur nameof
pour obtenir le nom de chaîne du paramètre à l'origine de l'exception. L'utilisation de l'opérateur nameof
permet de garder votre code valide lorsque vous renommez des définitions.
Si vous exécutez le code, une exception devrait être levée, car userName
est null et spécifiez également le nom du paramètre. identifier facilement le paramètre à l'origine de l'exception.
Conclusion
Une exception est levée lorsqu'une erreur est rencontrée dans une application en cours d'exécution. Cela peut être dû à un code incorrect ou à une entrée utilisateur incorrecte qui n'a pas été prise en compte dans le code de l'application.
Dans cet article, nous avons examiné deux types d'exception standard du .NET Framework, les types ArgumentNullException
et ArgumentOutOfRangeException
. L'exception ArgumentOutOfRangeException
est renvoyée lorsque la valeur d'un argument est en dehors de la plage attendue de valeurs définie par la méthode invoquée. L'exception ArgumentOutOfRangeException
résulte normalement d'une erreur du développeur. Par conséquent, lorsque vous traitez ce type d'erreur, veillez à lire la valeur des propriétés Message
ParamName
. Valeur réelle
. La ArgumentNullException
est levée lorsqu'une valeur null
est transmise à une méthode qui n'accepte pas les valeurs null en tant qu'entrée valide. Ils sont fournis pour que le code d'application puisse faire la distinction entre les exceptions causées par des arguments nuls et les exceptions causées par des arguments non nuls.
Les commentaires sont désactivés en mode Aperçu.
Source link