Kompilierung von C#-Grundkenntnissen: Ausnahme für Grundkenntnisse (13).

Wenn wir Code schreiben, stoßen wir während des Betriebs häufig auf bestimmte Probleme, die zum Absturz des Programms führen. Dies liegt nicht daran, dass das Programmierniveau nicht gut ist, sondern an Problemen mit der Geschäftslogik, dem Betriebssystem oder anderen Geräten wie Computern. Beispielsweise werden einige Methoden in user32.dll häufig in C# verwendet , Ihr Programm kann immer noch nicht ausgeführt werden. Als erfahrener Programmierer müssen Sie beim Schreiben eines Programms natürlich immer verschiedene Situationen berücksichtigen. Je höher das Niveau, desto mehr Situationen müssen Sie berücksichtigen und desto geringer ist die Wahrscheinlichkeit, dass Ihr Programm abstürzt besser die Robustheit.
Im Allgemeinen gibt es zwei Situationen, in denen das Programm nicht ausgeführt werden kann:
Eine davon ist ein Fehler. Dazu gehören Umgebungsfehler (z. B. fehlende Dateien, falscher Dateiinhalt, was zu Inkonsistenzen mit Programmkonventionen führt, nicht unterstützte Systemversionen usw.); ist im Allgemeinen Prozessfehler führen zu falschen Ergebnissen im Programm usw.);
Das zweite sind Ausnahmen. Eine Ausnahme bedeutet, dass das Programm aufgrund von Faktoren im aktuellen Prozess oder unerwartetem Verhalten nicht ausgeführt werden kann. Im Allgemeinen umfassen:
Illegale Vorgänge, falsche Eingaben durch den Benutzer, abnormale Eingaben und Ausgaben, nicht hardwarebedingte Probleme beim Zugriff auf externe Geräte, z. B. beim Lesen und Schreiben von Festplatten. Das Ergebnis ist, dass externe virtuelle optische Laufwerke, Disketten usw. usw. werden auch als Festplatten verwendet, oder Es gibt kein Problem mit dem Programm selbst, aber es werden immer noch Fehler gemeldet, wenn die Speicherzuordnung beim Lesen und Schreiben von der Festplatte abnormal ist und wenn der Speicher nicht ausreicht, können keine neuen Objekte erstellt werden.
Im Allgemeinen gibt es einen wesentlichen Unterschied zwischen Fehlern und Ausnahmen. Sobald Fehler auftreten, müssen sie geändert werden, und die Betriebsumgebung muss auf jeden Fall geändert werden Das Programm ist mehr oder weniger Alle Arten von Ausnahmen werden auftreten. Wenn Ausnahmen auftreten, muss das Programm Ausnahmen behandeln, aber Ausnahmen sollten den weiteren Betrieb des Programms nicht beeinträchtigen. Korrigieren Sie Fehler, sobald sie auftreten. Werfen wir einen Blick auf die Ausnahmebehandlung in C#.
Um sicherzustellen, dass das Programm keine Fehler macht, werden im Allgemeinen viele Urteile gefällt, wenn...sonst, aber ein weiser Mann wird nach sorgfältiger Überlegung Fehler machen. Selbst ein großartiger Mensch kann das Programm nicht machen umfassend und denken Sie an alle Situationen. Auf diese Weise sollten wir die Ausnahmebehandlung in C# verwenden. C# verwendet ein Catch-and-Throw-Modell zur Behandlung von Ausnahmen. Wenn im Programm eine Ausnahme auftritt, wird das Ausnahmeobjekt an der Stelle erfasst, an der die Ausnahme behandelt wird. Was geworfen wird, ist ein Objekt der Exception-Klasse oder ihrer Unterklasse, wie zum Beispiel:
ArgumentException: Diese Ausnahme wird geworfen, wenn der Parameter unzulässig ist.
ArgumentNullException: Diese Ausnahme wird ausgelöst, wenn der Parameter null ist.
ArgumentOutOfRangeException: Diese Ausnahme wird ausgelöst, wenn der Parameter den zulässigen Bereich überschreitet.
Das Format zum Erfassen von Ausnahmen ist wie folgt:

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

Der Try-Codeblock enthält Code, der Ausnahmen verursachen kann. Sie können das Schlüsselwort throw verwenden, um Ausnahmen auszulösen, oder Sie können auf beliebige Eigenschaften oder Methoden zugreifen ;
Der Catch-Codeblock wird zum Erfassen der abzufangenden Ausnahme verwendet und enthält den Code zur Behandlung der Ausnahme.
Der Codeblock stellt schließlich das Codesegment dar, das nach Abschluss der Ausnahmebehandlung ausgeführt wird. Das heißt, das Codesegment in „final“ wird immer zuletzt ausgeführt, unabhängig davon, ob die Ausnahme abgefangen wird.
Sehen Sie sich die folgenden Codeteile an:
Von Exception geerbt und verstehen Sie intuitiv die Exception-Klasse:

  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;
            }
        }
    }

Sehen Sie sich den Prozess des Fangens und Werfens an:

  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("木有抛出异常");
        }
    }

// Aufruf:

   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();
        }
    }

Sie können sehen, dass das Programm im Try-Codeblock, sobald es das Schlüsselwort throw erreicht, sofort die Ausführung des nachfolgenden Codes stoppt und dann zum entsprechenden Throw-Ausnahmeobjekttyp springt . Im Catch-Codeblock ausführen. Daher ist das Catch-and-Throw-Modell eine intuitivere und vernünftigere Möglichkeit, Ausnahmen zu behandeln.

Das Obige ist die Zusammenstellung der Grundkenntnisse von C#: Grundkenntnisse (13) Abnormaler Inhalt. Weitere verwandte Inhalte finden Sie auf der chinesischen PHP-Website (www.php.cn)!