Обработка исключений

Операторы checked и unchecked

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

static void Main()
{
 byte x = 200; byte y = 200;
 byte result = (byte) (x + y);
 Console.WriteLine(result);
}

Здесь сумма значений а и b превышает диапазон представления значений типа byte. Следовательно, результат данного выражения не может быть записан в переменную result, тип которой byte.

Для управления подобными исключениями в С# используются операторы checked и unchecked. Чтобы указать, что некоторое выражение должно быть проконтролировано на предмет переполнения, используйте ключевое слово checked. А чтобы проигнорировать переполнение, используйте ключевое слово unchecked. В последнем случае результат будет усечен так, чтобы его тип соответствовал типу-результату выражения.

Можно задать (или отключить) проверку переполнения сразу для всего проекта. Для этого необходимо выполнить следующие действия

Оператор checked имеет две формы:

checked ((тип-выражения) expr)

checked 
{
 // Инструкции, подлежащие проверке.
}

Оператор unchecked также имеет две формы:

unchecked ((тип-выражения) expr)

unchecked 
{
 // Инструкции, для которых переполнение игнорируется.
}

Рассмотрим пример программы, которая демонстрирует использование checked и unchecked.

static void Main()
{
 byte x = 200; byte y = 200;
 try
 {
  byte result = unchecked((byte)(x + y)); 
  Console.WriteLine("1: {0}", result);
  result = checked((byte)(x + y));
  Console.WriteLine("2: ", result);
 }
 catch (OverflowException)
 {
  Console.WriteLine("возникло переполнение");
 }
}

Результат выполнения программы:

1: 144
возникло переполнение

В данном примере мы посмотрели, как использовать checked и uncheсked для проверки выражения. А теперь посмотрим, как использовать их для контроля за блоком инструкций.

static void Main()
{
 byte n = 1; byte i;
 try
 {
  unchecked	//блок без проверки
  {
   for (i = 1; i < 10; i++) n *= i;
   Console.WriteLine("1: {0}", n);
  }
  checked 	//блок с проверкой
  {
   n=1;
   for (i = 1; i < 10; i++) n *= i;
   Console.WriteLine("2: ", n);
  }
 }
 catch (OverflowException)
 {
  Console.WriteLine("возникло переполнение");
 }
}

Результат выполнения программы:

1: 128
возникло переполнение

Генерация собственных исключений

До сих пор мы рассматривали исключения, которые генерирует среда, но сгенерировать исключение может и сам программист. Для этого необходимо воспользоваться оператором throw, указав параметры, определяющие вид исключения. Параметром должен быть объект, порожденный от стандартного класса System.Exception. Этот объект используется для передачи информации об исключении обработчику.

static void Main()
{
 try
 {
  int x = int.Parse(Console.ReadLine());
  if (x < 0) throw new Exception(); //1
  Console.WriteLine("ok");
 }
 catch 
 {
  Console.WriteLine("введено недопустимое значение");
 }
}

В строчке 1 c помощью команды new был создан объект исключения типа Exception. При необходимости можно генерировать исключение любого типа.

При генерации исключения можно определить сообщение, которое будет "выбрасываться" обработчиком исключений. Например:

static void Main()
{
 try
 {
  int x = int.Parse(Console.ReadLine());
  if (x < 0) throw new Exception("введено недопустимое значение"); //1
  Console.WriteLine("ok");
 }
 catch (Exception error)
 {
  Console.WriteLine(error.Message);
 } 
}

Полезные совет

Рассмотрим несколько полезных приемов использования обработчиков исключений.

Пример 1. Один try -блок можно вложить в другой. Исключение, сгенерированное во внутреннем try -блоке и не перехваченное catch -инструкцией, которая связана с этим try -блоком, передается во внешний try -блок. Например, в следующей программе исключение типа ArithmeticException перехватывается не внутренним try -блоком, а внешним.

static void Main()
{
 Console.WriteLine("a=");
 byte a = byte.Parse(Console.ReadLine());
 Console.WriteLine("b=");
 byte b = byte.Parse(Console.ReadLine());
 int f=1;
 try //Внешний блок-try
 {
  for (byte i = a; i <= b; ++i)
  {
   try //Внутренний блок-try
   {
    f=checked((int)(f*i));
    Console.WriteLine("y({0})={1:f6}", i, 100 / (f - 1));
   }
   catch (DivideByZeroException)
   {
    Console.WriteLine("y({0})=Деление на 0", i);
   }
  }
 }
 catch (ArithmeticException)
 {
  Console.WriteLine("ERROR");
 }
}

Использование вложенных try -блоков обусловлено желанием обрабатывать различные категории ошибок различными способами. Одни типы ошибок носят катастрофический характер и не подлежат исправлению. Другие — неопасны для дальнейшего функционирования программы, и с ними можно справиться прямо на месте их возникновения. Поэтому внешний try -блок можно использовать для перехвата самых серьезных ошибок, позволяя внутренним try -блокам обрабатывать менее опасные.

Пример 2. Исключение, перехваченное одной catch -инструкцией, можно сгенерировать повторно, чтобы обеспечить возможность его перехвата другой (внешней) catch -инструкцией. Это позволяет нескольким обработчикам получить доступ к исключению.

static void genException ()
{
 Console.WriteLine("a=");
 double a = double.Parse(Console.ReadLine());
 Console.WriteLine("b=");
 double b = double.Parse(Console.ReadLine());
 int f = 1;
 try //Внешний блок-try
 { 
  for (double i = a; i <= b; ++i)
  {
   try //Внутренний блок-try
   {
    f = checked((int)(f * i));
    Console.WriteLine("y({0})={1:f6}", i, 100 / (f - 1));
  }
  catch (DivideByZeroException)
  {
   Console.WriteLine("y({0})=Деление на 0", i);
   }
  }
 }
 catch (ArithmeticException)
 {
  Console.WriteLine("ERROR");
  throw ; //повторная генерация исключения
 }
}

static void Main()
{
 try
 {
  genException();
 }
 catch
 {
  Console.WriteLine("НЕИСПРАВИМАЯ ОШИБКА!!!");
 }
}

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

Пример 3.Как упоминалось выше, тип исключения должен совпадать с типом, заданным в catch -инструкции. В противном случае это исключение не будет перехвачено. Можно перехватывать все исключения, используя catch -инструкцию без параметров. Кроме того, с try -блоком можно связать не одну, а несколько catch -инструкций. В этом случае все catch-инструкции должны перехватывать исключения различного типа. Если вы все же не уверены, что предусмотрели все ситуации, то последней можно добавить catch -инструкцию без параметров.

static void Main()
{
 for (int i = 0; i < 5; i++)
 {
  try
  {
   Console.WriteLine("Введите два числа");
   int a = int.Parse(Console.ReadLine());
   int b = int.Parse(Console.ReadLine());
   Console.WriteLine(a+"/"+b+"="+a/b);
  }
  catch (FormatException)
  {
   Console.WriteLine("Нужно ввести число!");
  }
  catch (DivideByZeroException)
  {
   Console.WriteLine("Делить на нуль нельзя!");
  }
  catch 
  {
   Console.WriteLine("Какая-то ошибка");
  }
  finally
  {
   Console.WriteLine("после try-блока");
  }
 }
}

a=4, b=2
a=3, b=g
a=d, b=1
a=2, b=0,
a=123456789987654321, b=1

Практикум

Постройте таблицу значений функции $$y=f(x)$$ для $$х \in [a, b]$$ с шагом $$h$$. Если в некоторой точке $$x$$ функция не определена, то выведите на экран сообщение об этом.

Замечание. При решении данной задачи использовать вспомогательный метод $$f(x)$$, реализующий заданную функцию, а также проводить обработку возможных исключений.

using System;
namespace Hello
{
 class Program
 {
  static double f(double x)
  {
   try
   {
    //если х не попадает в область определения, то генерируется исключение 
    if (x == -1) throw new Exception();  
    else return 1 / Math.Pow(1 + x, 2);
   }
   catch
   {
    throw;
   }
  }
  
  static void Main(string[] args)
  {
   try
   {
    Console.Write("a=");
    double a = double.Parse(Console.ReadLine());
    Console.Write("b=");
    double b = double.Parse(Console.ReadLine());
    Console.Write("h=");
    double h = double.Parse(Console.ReadLine());
    for (double i = a; i <= b; i += h)
    try
    {
     Console.WriteLine("y({0})={1:f4}", i, f(i));
    }
    catch
    {
     Console.WriteLine("y({0})=error", i);
    }    
   }
   catch (FormatException)
   {
    Console.WriteLine("Неверный формат ввода данных");
   }
   catch
   {
    Console.WriteLine("Неизвестная ошибка");
   }
  }
 }
}

Самостоятельная работа

Теоретический материал

Вычисление конечных сумм и произведений

Решение многих задач связано с нахождением суммы или произведения элементов заданной последовательности. В данном разделе мы рассмотрим основные приемы вычисления конечных сумм и произведений.

Пусть $$u_{1}(x), u_{2}(x), \dots, u_{n}(x)$$ - произвольная последовательность n функций. Будем рассматривать конечную сумму вида $$u_{1}(x) + u_{2}(x) + \dots + u_{n}(x)$$. Такую сумму можно записать более компактно, используя следующее обозначение: $$u_1(x) + u_2(x) + … + u_n(x) = \sum_{i=1}^n{u_i(x)}$$. При $$n \le 0$$ значение суммы равно 0.

В дальнейшем будем также использовать сокращенную запись для конечного произведения данной последовательности, которая выглядит следующим образом: $$u_1(x) \cdot u_2(x) \cdot … \cdot u_n(x) = \prod_{i=1}^n{u_i(x)}$$.

static void Main()
{
 Console.Write("Ввведите значение n: ");
 int n=int.Parse(Console.ReadLine());
 int s=0;
 for (int i=1; i<=n; ++i)
  s+=i;
 Console.WriteLine("s="+s);
}

static void Main()
{
 Console.Write("Ввведите значение n: ");
 int n=int.Parse(Console.ReadLine());
 int f=1;
 for (int i=1; i<=n; ++i)
 f*=i;
 Console.WriteLine("{0}!={1}", n, f);
}

static void Main()
{
 Console.Write("Ввведите значение n: ");
 int n=int.Parse(Console.ReadLine());
 Console.Write("Ввведите значение x: ");
 double x=double.Parse(Console.ReadLine());
 double b=0, s=0;
 for (int i=1; i<=n; ++i)
 {
  b+=Math.Cos(i*x);
  s+=b/i;
 }
 Console.WriteLine("s={0:f2}",s);
}

using System;

namespace Hello
{
 class Program
 {
  static void Main()
  {
   Console.Write("Ввведите значение n: ");
   int n=int.Parse(Console.ReadLine());
   Console.Write("Ввведите значение x: ");
   double x=double.Parse(Console.ReadLine());
   double a=-1, s=0;
   for (int i=1; i<=n; ++i)
   {
    a*=-x/i;  s+=a;
   }
   Console.WriteLine("s={0:f2}",s);
  }
 }
}

Вычисление бесконечных сумм

Будем теперь рассматривать бесконечную сумму вида $$u_1(x) + u_2(x) + … + u_n(x) +…= \sum_{i=1}^{\infty}{u_i(x)}$$. Это выражение называется функциональным рядом. При различных значениях $$x $$ из функционального ряда получаются различные числовые ряды $$a_1 + a_2 + … + a_n +…= \sum_{i=1}^{\infty}{a_i}$$. Числовой ряд может быть сходящимся или расходящимся. Совокупность значений $$x$$, при которой функциональный ряд сходится, называется его областью сходимости.

Числовой ряд называется сходящимся, если сумма n первых его членов $$S_{n}=a_{1}+ a_{2}+ \dots + a_{n} + \dots $$ при $$n\to\infty$$ имеет предел, в противном случае, ряд называется расходящимся. Ряд может сходиться лишь при условии, что общий член ряда $$a_{n}$$ при неограниченном увеличении его номера стремится к нулю: $$\lim_{n\to\infty}{a_n}=0$$. Это необходимый признак сходимости для всякого ряда.

В случае бесконечной суммы будем вычислять ее с заданной точностью $$e$$. Cчитается, что требуемая точность достигается, если вычислена сумма нескольких первых слагаемых и очередное слагаемое оказалось по модулю меньше чем е, то есть это слагаемое на результат практически не влияет. Тогда его и все последующие слагаемые можно не учитывать.

Пример. Написать программу для подсчета суммы $$\sum_{i=1}^{\infty}{\frac{(-1)^i}{i!}}$$ с заданной точностью $$е$$ ( $$е > 0$$ ).

using System;
namespace Hello
{
 class Program
 {
  static void Main()
  {
   Console.Write("Задайте точность вычислений е: ");
   double e=double.Parse(Console.ReadLine());
   double a=-1, s=0;
   for (int i=2; Math.Abs(a)>=e; ++i)
   {
    s+=a;
    a/=-i;
   }
   Console.WriteLine("s={0:f2}",s);
  }
 }
}

Практическое задание