Обработка многочисленных исключений

Применение нескольких операторов catch

С одним оператором try можно связать несколько операторов catch. И на практике это делается довольно часто. Но все операторы catch должны перехватывать исключения разного типа:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Collections;

namespace ConsoleApplication1
{
   class Program
    {
        static void Main()
        {
            try
            {
                Console.Write("Введите число типа byte: ");
                byte b = byte.Parse(Console.ReadLine());
                int[] myArr = new int[5] { 1, 2, 0, 10, 12 };
                Console.WriteLine("Исходный массив: ");

                for (int j = 0; j <= myArr.Length; j++)
                    Console.WriteLine("{0}\t", myArr[j]);

                int i = 120;
                Console.WriteLine("\nДелим на число: \n");
                foreach (int d in myArr)
                    Console.WriteLine(i / d);
            }
            // Обрабатываем исключение, возникающее
            // при арифметическом переполнении
            catch (OverflowException)
            {
                Console.Write("Данное число не входит в диапазон 0 - 255");
            }
            // Исключение при делении на 0
            catch (DivideByZeroException)
            {
                Console.WriteLine("Делить на ноль нельзя");
            }
            // Исключение при переполнении массива
            catch (IndexOutOfRangeException)
            {
                Console.WriteLine("Индекс выходит за пределы\n");
            }

            Console.ReadLine();
        }
    }
}

Как следует из приведенного выше результата, каждый оператор catch реагирует только на свой тип исключения.

Вообще говоря, операторы catch выполняются по порядку их следования в программе. Но при этом выполняется только один блок catch, в котором тип исключения совпадает с типом генерируемого исключения. А все остальные блоки catch пропускаются.

Перехват всех исключений

Время от времени возникает потребность в перехвате всех исключений независимо от их типа. Для этой цели служит оператор catch, в котором тип и переменная исключения не указываются. Ниже приведена общая форма такого оператора:

catch {
// обработка исключений
}

С помощью такой формы создается "универсальный" обработчик всех исключений, перехватываемых в программе. Давайте модифицируем предыдущий пример и добавим вместо трех операторов catch, следующий код:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Collections;

namespace ConsoleApplication1
{
   class Program
    {
        static void Main()
        {
            try
            {
                Console.Write("Введите число типа byte: ");
                byte b = byte.Parse(Console.ReadLine());
                int[] myArr = new int[5] { 1, 2, 0, 10, 12 };
                Console.WriteLine("Исходный массив: ");

                for (int j = 0; j <= myArr.Length; j++)
                    Console.WriteLine("{0}\t", myArr[j]);

                int i = 120;
                Console.WriteLine("\nДелим на число: \n");
                foreach (int d in myArr)
                    Console.WriteLine(i / d);
            }
            // Обрабатываем все исключения
            catch {
                Console.WriteLine("Возникла непредвиденная ошибка");
            }

            Console.ReadLine();
        }
    }
}

В подавляющем большинстве случаев "универсальный" обработчик исключений не применяется. Как правило, исключения, которые могут быть сгенерированы в коде, обрабатываются по отдельности. Неправильное использование "универсального" обработчика может привести к тому, что ошибки, перехватывавшиеся при тестировании программы, маскируются. Кроме того, организовать надлежащую обработку всех исключительных ситуаций в одном обработчике не так-то просто. Иными словами, "универсальный" обработчик исключений может оказаться пригодным лишь в особых случаях, например в инструментальном средстве анализа кода во время выполнения.

Вложение блоков try

Один блок try может быть вложен в другой. Исключение, генерируемое во внутреннем блоке try и не перехваченное в соответствующем блоке catch, передается во внешний блок try:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Collections;

namespace ConsoleApplication1
{
   class Program
    {
        static void Main()
        {
            Console.Write("Введите длину массива: ");
            try
            {
                int i = int.Parse(Console.ReadLine());
                int[] myArr = new int[i];
                Console.WriteLine("\nВведите теперь элементы массива: ");
                for (int j = 0; j < i; j++)
                {
                    Console.Write("{0}й элемент: ",j+1);
                    // Вложенный оператор try
                    try
                    {
                        myArr[j] = int.Parse(Console.ReadLine());
                    }
                    catch(OverflowException)
                    {
                        Console.WriteLine("Слишком большое число");
                    }
                }

            }
            catch (FormatException ex)
            {
                Console.WriteLine("ОШИБКА: " + ex.Message);
            }

            Console.ReadLine();
        }
    }
}

Обратите внимание, что во вложенном операторе try не определяется исключение для нарушения формата ввода элементов массива, но при этом, данное исключение перехватывается внешним блоком try. Стоит отметить, что количество вложенных операторов try не ограничено.