Fermer

avril 30, 2019

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