Compilation des connaissances de base C# : exception des connaissances de base (13)

Souvent, lorsque nous écrivons du code, nous rencontrons toujours certains problèmes pendant le fonctionnement qui provoquent le crash du programme. Ce n'est pas parce que le niveau du programmeur n'est pas bon, mais à cause de problèmes avec la logique métier, le système d'exploitation ou d'autres équipements tels que les ordinateurs. Par exemple, certaines méthodes de user32.dll sont souvent utilisées en C#. , votre programme ne peut toujours pas s'exécuter. Bien sûr, en tant que programmeur expérimenté, vous devez toujours prendre en compte diverses situations lors de l'écriture d'un programme. Plus le niveau est élevé, plus vous devez considérer de situations, et plus vous y réfléchissez, moins votre programme risque de planter. meilleure est la robustesse.
De manière générale, il existe deux situations dans lesquelles le programme ne peut pas s'exécuter :
L'une est une erreur. Il inclut les erreurs d'environnement (telles que des fichiers manquants, un contenu de fichier incorrect, entraînant une incohérence avec l'accord du programme, des versions du système non prises en charge, etc.) ; il s'agit généralement d'erreurs de processus qui conduisent à des résultats erronés dans le programme, etc.);
La seconde concerne les exceptions. Une exception signifie que le programme ne peut pas s'exécuter en raison de facteurs liés au processus en cours ou d'un comportement inattendu. Incluent généralement :
 Opération illégale, l'utilisateur saisit des instructions erronées ; entrées et sorties anormales, problèmes non matériels lors de l'accès à des périphériques externes, tels que lors de la lecture et de l'écriture de disques durs, le résultat est que des lecteurs optiques virtuels externes, des disquettes, etc. sont également utilisés comme disques durs, ou Il n'y a aucun problème avec le programme lui-même, mais des erreurs sont toujours signalées lors de la lecture et de l'écriture à partir du disque dur ; l'allocation de mémoire est anormale et lorsque la mémoire est insuffisante, de nouveaux objets ne peuvent pas être créés.
De manière générale, il existe une différence clé entre les erreurs et les exceptions. Les erreurs ne sont pas autorisées à se produire, le programme doit être modifié et l'environnement d'exploitation doit être modifié, quoi qu'il arrive. Le programme est plus ou moins Tous les types d'exceptions seront rencontrés. Lorsque des exceptions se produisent, le programme doit gérer les exceptions, mais les exceptions ne doivent pas affecter le fonctionnement continu du programme. Pour les erreurs, corrigez-les lorsqu’elles surviennent. Jetons un coup d'œil à la gestion des exceptions en C#.
D'une manière générale, afin de garantir que le programme ne commet pas d'erreurs, de nombreux jugements seront portés si... sinon, mais un homme sage fera des erreurs après un examen attentif. Même une grande personne ne peut pas réaliser le programme. globale et penser à toutes les situations. C’est donc ainsi que nous devrions utiliser la gestion des exceptions en C#. C# utilise un modèle catch-and-throw pour gérer les exceptions Lorsqu'une exception se produit dans le programme, l'objet d'exception est capturé à l'endroit où l'exception est gérée. Ce qui est lancé est un objet de la classe Exception ou de sa sous-classe, tel que :
ArgumentException : Cette exception est levée lorsque le paramètre est illégal.
ArgumentNullException : Cette exception est levée lorsque le paramètre est nul.
ArgumentOutOfRangeException : cette exception est levée lorsque le paramètre dépasse la plage autorisée.
Le format de capture des exceptions est le suivant :

            try
            {
                //代码段
            }
            catch (Exception ex)
            {
                //处理异常
            }
            finally
            {
                //最后一定执行的
            }

Le bloc de code try contient du code qui peut provoquer des exceptions. Vous pouvez utiliser le mot-clé throw pour lancer des exceptions, ou vous pouvez accéder à n'importe quelle propriété ou méthode. qui peut générer des exceptions. ;
le bloc de code catch est utilisé pour capturer l'exception à intercepter et contient le code pour gérer l'exception ;
finalement le bloc de code représente le segment de code qui est exécuté une fois la gestion de l'exception terminée, c'est-à-dire que le segment de code dansfinal est toujours exécuté en dernier, que l'exception soit interceptée ou non.
Regardez les morceaux de code suivants :
Hérité d'Exception et comprenez intuitivement la classe Exeption :

  public class MySelfException : Exception
    {
        /// <summary>
        /// 默认构造器
        /// </summary>
        public MySelfException()

            : base()
        {

        }
        /// <summary>
        /// 提供一个string类型的参数构造器，可设置自定义信息
        /// </summary>
        /// <param name="message"></param>
        public MySelfException(string message)

            : base(message)
        {

        }

        /// <summary>
        /// 用于传入异常信息，另外可以传入该异常有哪个其它异常引发的
        /// </summary>
        /// <param name="message"></param>
        /// <param name="innerException"></param>
        public MySelfException(string message, Exception innerException)

            : base(message, innerException)
        {

        }
        /// <summary>
        /// 覆盖Message属性，返回经过处理的异常信息
        /// </summary>
        public override string Message
        {
            get
            {
                return "有异常：" + base.Message;
            }
        }
    }

Regardons le processus d'attraper et de lancer :

  public class Exceptions
    {
        public static void PersonInfo(string name, char sex, int age)
        {
            if (string.IsNullOrEmpty(name))
            {
                throw new ArgumentNullException("name");
            }

            if (sex != '男' && sex != '女')
            {
                throw new ArgumentException("sex只能为“男”或“女”");
            }

            if (age <= 0 || age >= 150)
            {
                throw new ArgumentOutOfRangeException("age");
            }

            Console.WriteLine(string.Format(@"name={0},sex={1},age={2}", name, sex, age));
        }

        public static void Throwable(bool canThrow, int num)
        {
            if (canThrow)
            {
                throw new MySelfException("测试异常");
            }

            Console.WriteLine(1 / num);

            Console.WriteLine("木有抛出异常");
        }
    }

// Appel :

   class Program
    {
        static void Main(string[] args)
        {
            try
            {
                // Exceptions.PersonInfo(null, '男', 22); 

                // Exceptions.PersonInfo("Purple", '呵呵', 22);

                Exceptions.PersonInfo("Purple", '男', 1000);

                //Exceptions.PersonInfo("Purple", '男', 22);

                Console.WriteLine("代码执行无错误");
            }
            catch (ArgumentNullException e)
            {
                Console.WriteLine(e.Message);

                Console.WriteLine(e.StackTrace);
            }
            catch (ArgumentOutOfRangeException e)
            {
                Console.WriteLine(e.Message);

                Console.WriteLine(e.StackTrace);
            }
            catch (ArgumentException e)
            {
                Console.WriteLine(e.Message);

                Console.WriteLine(e.StackTrace);
            }

            Console.ReadLine();
        }
    }

Vous pouvez voir que dans le bloc de code try, une fois que le programme atteint le mot-clé throw, il arrête immédiatement d'exécuter le code suivant, puis passe à l'objet d'exception throw correspondant tapez Exécuter dans le bloc de code catch. Par conséquent, le modèle catch-and-throw est un moyen plus intuitif et plus raisonnable de gérer les exceptions.

Ce qui précède est la compilation des connaissances de base de C# : Connaissances de base (13) Contenu anormal, veuillez faire attention au site Web PHP chinois (www.php.cn) pour plus de contenu connexe !