Foreversoft.ru

IT Справочник
1 просмотров
Рейтинг статьи
1 звезда2 звезды3 звезды4 звезды5 звезд
Загрузка...

C exception ошибка

Урок №182. Обработка исключений. Операторы throw, try и catch

Обновл. 12 Янв 2020 |

В предыдущем уроке мы говорили о необходимости и пользе исключений. Исключения в C++ реализованы с помощью трёх ключевых слов, которые работают в связке друг с другом: throw, try и catch.

Генерация исключений

Мы постоянно используем сигналы в реальной жизни для обозначения того, что произошли определённые события. Например, во время игры в баскетбол, если игрок совершил серьёзный фол, то арбитр свистит, и игра останавливается. Затем идёт пенальти. Как только пенальти выполнено, игра возобновляется.

В C++ оператор throw используется, чтобы сигнализировать о возникновении исключения или ошибки (аналогия: арбитр свистит). Сигнализирование о том, что произошло исключение, называется генерацией исключения (или ещё «выбрасыванием исключения»).

Для использования оператора throw используется ключевое слово throw, за которым указывается значение любого типа данных, которое вы хотите использовать, чтобы сигнализировать об ошибке. Как правило, этим значением является код ошибки, описание проблемы или настраиваемый класс-исключение. Например:

Каждая из этих строк сигнализирует о том, что возникла какая-то ошибка, которую нужно обработать.

Поиск исключения

Выбрасывание исключений — это только одна часть процесса обработки исключений. Вернёмся к нашей аналогии с баскетболом: как только арбитр свистнул, что происходит дальше? Игроки останавливаются, и игра временно прекращается. Обычный поток выполнения игры нарушен.

В C++ мы используем ключевое слово try для определения блока стейтментов (так называемого «блока try»). Блок try действует как наблюдатель, в поисках исключений, которые были выброшены каким-либо из операторов в этом же блоке try. Например:

Обратите внимание, блок try не определяет, КАК мы будем обрабатывать исключение. Он просто сообщает компилятору: «Эй, если какой-либо из стейтментов внутри этого блока try выбросит исключение — лови его!».

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

Пока арбитр не объявит о пенальти, и пока это пенальти не будет выполнено, игра не возобновится. Другими словами, пенальти должно быть обработано до возобновления игры.

Фактически, обработка исключений — это работа блока(ов) catch. Ключевое слово catch используется для определения блока кода (так называемого «блока catch»), который обрабатывает исключения определённого типа данных.

Вот пример блока catch, который обрабатывает (ловит) исключения типа int:

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

Как только исключение было поймано блоком try и направлено в блок catch для обработки, оно считается обработанным (после выполнения кода блока catch), и выполнение программы возобновляется.

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

Как и в случае с функциями, если параметр не используется в блоке catch, то имя переменной можно не указывать:

Это предотвратит вывод предупреждений компилятора о неиспользуемых переменных.

throw, try и catch вместе

Вот полная программа, которая использует throw, try и несколько блоков catch:

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

We caught an int exception with value -1
Continuing our way!

Оператор throw используется для генерации исключения -1 типа int. Затем блок try обнаруживает оператор throw и перемещает его в соответствующий блок catch, который обрабатывает исключения типа int. Блок catch типа int и выводит соответствующее сообщение об ошибке.

После обработки исключения, программа продолжает своё выполнение и выводит на экран Continuing our way! .

Резюмируем

Обработка исключений, на самом деле, довольно-таки проста, и всё, что вам нужно запомнить, размещено в следующих двух абзацах:

При выбрасывании исключения (оператор throw), точка выполнения программы немедленно переходит к ближайшему блоку try. Если какой-либо из обработчиков catch, прикреплённых к блоку try, обрабатывает этот тип исключения, то точка выполнения переходит в этот обработчик и, после выполнения кода блока catch, исключение считается обработанным.

Если подходящих обработчиков catch не существует, то выполнение программы переходит в следующий блок try. Если до конца программы не найдены соответствующие обработчики catch, то программа завершает своё выполнение с ошибкой исключения.

Обратите внимание, компилятор не выполняет неявные преобразования при сопоставлении исключений с блоками catch! Например, исключение типа char не будет обрабатываться блоком catch типа int, исключение типа int, в свою очередь, не будет обрабатываться блоком catch типа float.

Это действительно всё, что вам нужно запомнить. Остальная часть этой главы будет посвящена демонстрации этих принципов на практике.

Исключения обрабатываются немедленно

Вот маленькая программа, которая демонстрирует, что исключения обрабатываются немедленно:

C exception ошибка

В этой статье (перевод [1]) раскрываются следующие вопросы, касающиеся обработки исключений (Exception):

• Базовые понятия исключений C# (с примерами)
• Общие исключения .NET
• Как создать свои собственные пользовательские типы исключений
• Как найти скрытые исключения .NET
• Как лучше всего документировать и отслеживать исключения C#

[Что такое исключение?]

Исключения (Exceptions) это тип ошибки, которая происходит при выполнении приложения. Ошибки обычно означают появление неожиданных проблем. Тогда как исключения, обработка которых организована в коде, являются ожидаемыми, они происходят в коде приложений по различным причинам.

Приложения используют логику обработки исключений (exception handling) для явной поддержки кодом каких-то неординарных событий. Причины исключений могут быть самые разные — от печально известного NullReferenceException до таймаута обращения к базе данных.

Анатомия исключений C#. Исключения позволяют передать управление из одной части кода в другую часть. Когда срабатывает/выбрасывается исключение (exception thrown), текущий поток выполнения кода секции try прерывается, и запускается выполнение секции catch. Обработка исключений C# осуществляется следующими ключевыми словами: try, catch, finally и throw.

try — блок try инкапсулирует проверяемый на исключение регион кода. Если любая строка кода в этом блоке вызывает срабатывание исключения, то исключение будет обработано соответствующим блоком catch.
catch — когда происходит исключение, запускается блок кода catch. Это то место, где Вы можете обработать исключения и предпринять адекватные для него действия, например записать событие ошибки в лог, прервать работу программы, или может просто игнорировать исключение (когда блок catch пустой).
finally — блок finally позволяет Вам выполнить какой-то определенный код приложения, если исключение сработало, или если оно не сработало. Например, освобождение объекта из памяти, который должен быть освобожден. Часто блок finally опускается, когда обработка исключения подразумевает нормальное дальнейшее выполнение программы — потому блок finally может быть просто заменен обычным кодом, который следует за блоками try и catch.
throw — ключевое слово throw используется для реального создания нового исключения, в результате чего выполнение кода попадет в соответствующие блоки catch и finally.

Читать еще:  Ошибка необъявленный идентификатор

Пример 1: базовый блок «try catch finally»

На языке C# ключевые слова try и catch используются для определения блока проверяемого кода (блок try catch). Блок try catch помещается вокруг кода, который потенциально может выбросить исключение. Если произошло исключение, то этот блок try catch обработает исключение, гарантируя тем самым, что приложение не выдаст ошибку необработанного исключения (unhandled exception) [5], ошибки пользователя, и эта ошибка не разрушит процесс выполнения приложения.

Ниже приведен простой пример метода, который выбрасывает исключение, и как нужно правильно использовать блок try catch finally для обработки ошибки.

Ваш код обработки исключения на C# может применить несколько операторов catch, предназначенных для разных типов исключений. Это может быть очень полезным — в зависимости от того, что делает код. В предыдущем примере ArgumentNullException возникнет только тогда, когда переданный URL сайта окажется null. WebException происходит из-за широкого массива разных проблем. Перехват определенных типов исключений может помочь в их обработке.

Пример 2: фильтры исключений

Одна из новых функций C# версии 6 был ввод фильтров исключений (exception filters). Они дают Вам еще больше контроля над блоками catch и дальнейшей обработкой определенных исключений. Это помогает точно подстроить код под то, как Вы обрабатываете исключения, и как Вы хотите их обработать.

До C# 6 Вы должны были поймать все типы WebException и обработать их. Теперь Вы можете принять решение только обработать их в определенных сценариях и позволить другому пузырю сценариев до кода который названный этим методом. Вот измененный пример с фильтрами:

[Общие исключения .NET]

Правильная обработка исключения критична для всего кода приложения. Имеется несколько часто используемых стандартных исключений (Common .NET Exceptions). Чаще всего стоит бояться исключения обращения по не инициализированной ссылке (null reference exception). Ниже приведен список общих ошибок, которые Вы будете наблюдать регулярно.

System.NullReferenceException — наиболее общее исключение, связанное с вызовом метода, когда его объект не инициирован.
System.IndexOutOfRangeException — произошла попытка доступа к не существующему элементу массива.
System.IO.IOException — используется в связи с файловыми операциями ввода/вывода (file I/O).
System.Net.WebException — обычно выбрасывается при любых ошибках, связанных с вызовами протокола HTTP.
System.Data.SqlClient.SqlException — различные типы исключений сервера SQL.
System.StackOverflowException — если метод рекурсивно вызывает сам себя, то Вы можете получить это исключение.
System.OutOfMemoryException — если приложение столкнулось с недостатком памяти.
System.InvalidCastException — если Вы попытались сделать приведение типа объекта (cast) к несовместимому типу.
System.InvalidOperationException — общее стандартное исключения в некоторых библиотеках.
System.ObjectDisposedException — попытка использовать объект, который уже освобожден.

[Как создать свои собственные пользовательские типы исключений]

Исключения C# определены как классы, точно так же, как и любой другой объект C#. Все исключения наследуются от базового класса System.Exception. Есть много общих исключений (common exceptions), которые Вы можете использовать в своем собственном коде. Обычно разработчики используют стандартный объект ApplicationException или Exception для выбрасывания пользовательских исключений (custom exceptions). Вы также можете создать свой собственный тип исключения.

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

Ниже приведен пример пользовательского типа исключений — ClientBillingException. Выставление счетов (Billing) это нечто такое, что Вы не захотели бы пропустить, и если такое происходит, то хотелось бы весьма определенным образом разобраться с обработкой такого исключения. С помощью пользовательского типа исключения для для такого события мы можем написать специальный код для исключения. Мы можем также мониторить наше приложение на такой специфический тип исключения, и оповещать человека по вызову, когда это событие произошло.

Преимущества пользовательского типа исключений C#:

• Вызов кода может осуществлять пользовательскую обработку Custom Exception Type
• Возможность пользовательского мониторинга вокруг этого Custom Exception Type

Пример Custom Exception Type:

[Как найти скрытые исключения .NET]

Что такое First Chance Exceptions (исключения первого шанса)? Нормальная ситуация для большого количества исключений быть выброшенными, пойманными и затем проигнорированными. Внутренний код .NET Framework даже выбрасывает некоторые исключения, которые отбрасываются. Одна из функций C# это так называемые исключения первого шанса (first chance exceptions). Это позволяет Вам увидеть каждое выбрасываемое исключение .NET Exception по отдельности.

Код, наподобие приведенного ниже, очень часто встречается в приложениях. Этот код может выбросить (throw) тысячи исключений в минуту, и никто никогда про это бы не узнал. Этот код из приложения, который показывал серьезные проблемы производительности из-за плохой обработки исключений. Исключения произойдут, если reader равен null, columnName равен null, columnName не существует в результатах, значение столбца было null, или если value неправильная для DateTime. Настоящее минное поле ошибок.

Как в Visual Studio разрешить First Chance Exceptions. Когда запускаете приложение в отладчике Visual Studio, Вы можете установить Visual Studio останавливаться (break) в любой момент, когда выбрасывается C# Exception. Это может помочь найти исключения в своем коде, о которых Вы не знали, что они существуют.

Чтобы получить доступ к настройкам исключений, перейдите в меню Debug -> Windows -> Exception Settings (Отладка -> Исключения. это меню доступно при активной сессии отладчика). Под «Common Language Runtime Exceptions» Вы можете выбрать типы исключений, на которых отладчик должен автоматически поставить точку останова. Хорошей мыслью будет поставить здесь везде галочки. Как только код остановится на исключении, Вы можете указать ему игнорировать этот определенный тип исключений, если хотите.

Как просмотреть все исключения с префиксом. Бесплатный Stackify .NET profiler [6] также может показать все Ваши исключения. Подробнее см. статью [7]. Решение Stackify Retrace [8] (платное) для Ваших серверов также может собирать все исключения первого шанса через .NET profiler. Без каких-либо изменений в коде или конфигурации ом может автоматически собрать и показать все исключения.

Читать еще:  Коды ошибок c

Как в коде подписаться на First Chance Exceptions. Среда .NET Framework предоставляет способ подписаться на событие, чтобы запускать функцию обратного вызова (callback) в любой момент возникновения исключения. Вы можете использовать это, чтобы перехватить все исключения. Хорошей мыслью организовать потенциальную подписку на исключения, чтобы выводить информацию о них в окно отладки. Это дало бы некоторое отображение текущей ситуации в приложении без загромождения информацией Ваших лог-файлов. Обычно подписка делается один раз при старте приложения — в методе Main() консольного приложения или в коде запуска (startup) web-приложения ASP.NET.

[Как лучше всего документировать и отслеживать исключения C#]

Правильная обработка исключения критична для любого приложения. Ключевой компонент — создание библиотеки записи в лог исключений. Подробнее про это см. статью «C# Logging Best Practices» [9]. Лучше всего записывать исключения с использованием библиотек NLog, Serilog или log4net. Все эти три фреймворка дают Вам возможность записывать исключения в файл. Также они позволяют отправлять Ваши логи различным другим получателям — база данных, система лога Windows (Windows Event Viewer), email, или служба мониторинга ошибок (error monitoring service). Любое исключение в приложении должно быть записано, это критично для поиска проблем в Вашем коде.

Также важно зарегистрировать больше дополнительных деталей по контексту возникновения исключения, что полезно для его диагностики и устранения причин ошибки. Это может быть информация о пользователе, ключевые используемые переменные и т. д.

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

Служба мониторинга ошибок — ключевой инструмент для любой команды разработки. Она позволяет централизованно собирать все Ваши исключения. Решение [8] предоставляет для этого следующие возможности:

• Централизованный лог исключений
• Просмотр и поиск всех исключений по всем серверам и приложениям
• Уникально идентифицировать каждое исключение
• Принимать оповещения на email о возникновении новых исключений или в случае слишком частого появления ошибок

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

Исключением является проблема, возникающая во время выполнения программы. Исключение C ++ — это ответ на исключительное обстоятельство, которое возникает во время работы программы, например попытка деления на ноль.

Исключения обеспечивают способ передачи контроля из одной части программы в другую. Обработка исключений C ++ построена на трех ключевых словах: try, catch и throw .

  • throw — программа выдает исключение, когда возникает проблема. Это делается с использованием ключевого слова throw .
  • catch — программа выхватывает исключение с обработчиком исключений в месте в программе, где вы хотите справиться с этой проблемой. Ключевое слово catch указывает на отлов исключения.
  • try — блок try идентифицирует блок кода, для которого будут активированы определенные исключения. За ним следует один или несколько блоков catch.

Предполагая, что блок вызовет исключение, метод поймает исключение, используя комбинацию ключевых слов try и catch . Блок try/catch помещается вокруг кода, который может генерировать исключение. Код внутри блока try/catch называется защищенным кодом и синтаксисом для использования try/catch следующим образом:

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

Выбросы исключений

Исключения могут быть выброшены в любом месте блока кода с использованием инструкции throw . Операнд оператора throw определяет тип исключения и может быть любым выражением, а тип результата выражения определяет тип созданного исключения.

Ниже приведен пример исключения исключения при делении на нулевое условие:

Устранение исключений

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

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

Ниже приведен пример, который генерирует деление на ноль, и мы поймаем его в блоке catch .

Поскольку мы создаем исключение типа const char * , поэтому, поймав это исключение, мы должны использовать const char * в блоке catch . Если мы скомпилируем и запустим код выше, это приведет к следующему результату:

Стандартные исключения C ++

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

std::exceptionИсключение и родительский класс всех стандартных исключений C ++.
std::bad_allocЭто может быть брошено new
std::bad_castЭто может быть вызвано dynamic_cast .
std::bad_exceptionЭто полезное устройство для обработки неожиданных исключений в программе на C ++.
std::bad_typeidЭто может быть вызвано typeid .
std::logic_errorИсключение, которое теоретически можно обнаружить, прочитав код.
std::domain_errorЭто исключение, возникшее при использовании математически недопустимого домена.
std::invalid_argumentЭто вызвано неправильными аргументами.
std::length_errorЭто генерируется при создании слишком большой std :: string.
std::out_of_rangeЭто может быть вызвано методом «at», например, std :: vector и std :: bitset <> :: operator [] ().
std::runtime_errorИсключение, которое теоретически невозможно обнаружить, прочитав код.
std::overflow_errorЭто бросается, если происходит математическое переполнение.
std::range_errorЭто происходит, когда вы пытаетесь сохранить значение, выходящее за пределы допустимого диапазона.
std::underflow_errorЭто бросается, если происходит математическое недополнение.

Определение новых исключений

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

Это приведет к следующему результату —

Здесь what() — это открытый метод, предоставляемый классом исключений, и он был переопределен всеми дочерними классами исключений. Это возвращает причину исключения.

C#: обработка ошибок

Исключения, их обработка, и некоторые другие моменты, связанные с ошибками в приложении на C#.

Исключения (Exceptions) и инструкция try

Инструкция try отмечает блок кода как объект для обработки ошибок или очистки. После блока try обязательно должен идти либо блок catch , либо блок finally , либо они оба. Блок catch выполняется, когда внутри блока try возникает ошибка. Блок finally выполняется после того, как прекращает выполнять блок try (или, если присутствует, блок catch ), независимо от того, выполнился ли он до конца или был прерван ошибкой, что позволяет выполнить так называемый код очистки.

Читать еще:  Ошибка при вызове openclipboard

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

Блок finally добавляет в программу прогнозируемость, позволяя выполнить определенный код при любых обстоятельствах. Это может быть полезно для выполнения операций очистки, например, закрытия сетевого подключения и т.д.

В целом конструкция try выглядит следующим образом:

Например, следующий код выбросит ошибку DivideByZeroException (поскольку делить на ноль нельзя) и наша программа завершить досрочно:

Чтобы этого избежать можно использовать конструкцию try :

Обработка исключений довольно ресурсоёмкая операция, поэтому на практике для таких случаев как в примере ее лучше не использовать (лучше непосредственно перед делением проверить делить на равенство нулю).

Когда выбрасывается исключение, CLR проверяет выброшено ли оно непосредственно внутри блока try , который может обработать данное исключение. Если да, выполнение переходит в соответствующий блок catch . Если блок catch успешно завершается, выполнение переходит к следующей после блока try инструкции (если имеется блок finally , то сначала выполняется он). Если же исключение выброшено не внутри блока try или конструкция try не содержит соответствующего блока catch , выполнение переходит в точку вызова метода (при этом сначала выполняется блок finally ), и проверка повторяется снова.

Если не одна функция в стэке вызовов не способна обработать исключение, ошибка выводиться пользователю и программа завершается досрочно.

Оговорка catch

В оговорке catch указывается какой тип исключения она должна перехватывать. Это может быть либо System.Exception , либо его производный класс. Перехватывая непосредственно System.Exception , мы перехватим все возможные ошибки. Это может быть полезно в нескольких случаях:

  • программа потенциально должна и может продолжить работать несмотря на ошибки любых типов
  • исключение будет выброшено повторно в блоке catch , например, после логирования ошибок
  • блок catch является последним в очереди, способным предотвратить аварийное завершение программы

Однако обычно перехватываются исключения более специфического типа, чтобы избежать ситуации, когда обработчику ошибки придется иметь дело с исключением, для которого он не предназначен (например, OutOfMemoryException ).

Можно обработать несколько типов исключений с помощью нескольких оговорок catch:

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

Исключение может быть перехвачено и без указания переменной, если не нужен доступ к ее членам:

Более того, в оговорке catch можно опустить и переменную и тип исключения — такая оговрка будет перехватывать все исключения:

Блок finally

Блок finally выполняется всегда, независимо от того выброшено исключение или нет. Блок finally обычно содержит код очистки.

Блок finally выполняется в следующих случаях:

  • после завершения блока catch
  • если выполнение блока try прервано jump-инструкциями: return , goto и т.д.
  • после выполнения блока try полностью, если исключений так и не было выброшено

Блок finally делает программу более прогнозируемой. Например, в следующем примере открываемый файл в итоге всегда будет закрыт, независимо от того, завершиться ли блок try без ошибок, или будет прерван выброшенным исключением, или сработает инструкция return если файл окажется пустым:

В пример для закрытия файла вызывается метод Dispose . Использование этого метода внутри блока finally является стандартной практикой. C# даже позволяет заменить всю конструкцию инструкцией using .

Инструкция using

Многие классы инкапсулируют неуправляемые ресурсы, такие как дескриптор файла, соединение с базой данных и т.д. Эти классы реализуют интерфейс System.IDisposable , который содержит единственный метод без параметров Dispose , освобождающий соответствующие машинные ресурсы. Инструкция using предусматривает удобный синтаксис вызова метода Dispose для объектов реализующих IDisposable внутри блока finally :

Что эквивалентно следующей конструкции:

Выбрасывание исключений

Исключение может быть выброшено автоматически во время выполнения программы либо явно в коде программы с помощью ключевого слова throw :

Также исключение может быть выброшено повторно внутри блока catch :

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

Если throw заменить на throw ex , то пример по прежнему будет работать, но свойство исключения StackTrace не будет отражать исходную ошибку.

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

В таких случаях необходимо передать исходное исключение в качестве первого параметра конструктора нового исключения, ссылка на объект исходного исключения позже будет доступна через свойство InnerException внутреннего исключения.

Основные свойства System.Exception

К наиболее важным свойствам класса System.Exception можно отнести:

  • StackTrace — строка, представляющая все методы, которые были вызваны, начиная с того, в котором было выброшено исключение, и заканчивая тем, в котором содержится блок catch , перехвативший исключение;
  • Message — строка с описанием ошибки;
  • InnerException — содержит ссылку на объект Exeption , который вызвал текущее исключение (например, при повторном выбрасывании исключения).

Основные типы исключений

Следующие типы исключений являются наиболее распространенными в среде CLR и .NET Framework. Их можно выбрасывать непосредственно или использовать как базовые классы для пользовательских типов исключений.

  • System.ArgumentException — выбрасывается при вызове функции с неправильным аргументом.
  • System.ArgumentNullException — производный от ArgumentException класс, выбрасывается если один из аргументов функции неожиданно равен null .
  • System.ArgumentOutOfRangeException — производный от ArgumentException класс, выбрасывается когда аргумент функции имеет слишком большое или слишком маленькое значение для данного типа (обычно касается числовых типов). Например, такое исключение будет выброшено если попытаться передать отрицательное число в функцию, которая ожидает только положительные числа.
  • System.InvalidOperationException — выбрасывается когда состояние объекта является неподходящим для нормального выполнения метода, например, при попытке прочесть не открытый файл.
  • System.NotSupportedException — выбрасывается, когда запрошенный функционал не поддерживается, например, если попытаться вызвать метод Add для коллекции доступной только для чтения (свойство коллекции IsReadOnly возвращает true ).
  • System.NotImplementedException — выбрасывается, когда запрошенный функционал еще не реализован.
  • System.ObjectDisposedException — выбрасывается при попытке вызвать метод объекта, который уже был уничтожен (disposed).

Директивы препроцессора

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

Ссылка на основную публикацию
Adblock
detector