Исключение как навигация: антипаттерн с тремя Попытками подряд

Исключение как навигация: антипаттерн с тремя Попытками подряд

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

Я считаю это одним из самых вредных антипаттернов в 1С. Не потому что конструкция запрещена. А потому что она выглядит как разумное решение, и поэтому очень часто принимается за хорошую практику. На самом деле она прячет ошибки именно там, где диагностика нужна больше всего.

Откуда история: парсинг таможенных деклараций

Я дорабатывал импортный учёт в торговой компании. Часть процесса — приём в систему таможенных деклараций (ГТД). Декларация приходит XML-файлом, который генерируется на стороне таможенных систем. Внутри — реквизиты партии: общая сумма, валюта, поставщик, страны ввоза, страна изготовителя, коды ТН ВЭД и так далее.

Сюрприз номер один — XML-формат не один. Со временем формат ГТД менялся, и один и тот же файл может прийти в одном из трёх вариантов: Declaration, GDC, GD. Различаются они названием корневого элемента и префиксами вложенных тегов. Структура данных внутри одинаковая, имена полей одинаковые, типы одинаковые. Просто один и тот же товарный реквизит лежит в одной декларации внутри DeclarationGoodsShipmentDetails, а в другой внутри GDCGoodsShipmentDetails, а в третьей — GDGoodsShipmentDetails.

Парсер должен был это учитывать.

Старое решение: каскад из Попыток

Код, который встретил меня при первом открытии модуля, выглядел примерно так:

Попытка
    Сумма = ОбъектXDTO.DeclarationGoodsShipmentDetails.GoodsValue;
    Валюта = ОбъектXDTO.DeclarationGoodsShipmentDetails.CurrencyCode;
    Поставщик = ОбъектXDTO.DeclarationGoodsShipmentDetails.SellerName;
    СтранаИзготовления = ОбъектXDTO.DeclarationGoodsShipmentDetails.OriginCountry;
    СтранаВвоза = ОбъектXDTO.DeclarationGoodsShipmentDetails.DeparturalCountry;
Исключение
    Попытка
        Сумма = ОбъектXDTO.GDCGoodsShipmentDetails.GoodsValue;
        Валюта = ОбъектXDTO.GDCGoodsShipmentDetails.CurrencyCode;
        Поставщик = ОбъектXDTO.GDCGoodsShipmentDetails.SellerName;
        СтранаИзготовления = ОбъектXDTO.GDCGoodsShipmentDetails.OriginCountry;
        СтранаВвоза = ОбъектXDTO.GDCGoodsShipmentDetails.DeparturalCountry;
    Исключение
        Попытка
            Сумма = ОбъектXDTO.GDGoodsShipmentDetails.GoodsValue;
            // ... и так далее ...
        Исключение
            Сумма = 0;
            Валюта = Неопределено;
            Поставщик = "";
            // ... обнулить всё ...
        КонецПопытки;
    КонецПопытки;
КонецПопытки;

Логика на первый взгляд выглядит понятной. Попытаться прочитать как Declaration. Если не получилось — попытаться как GDC. Если и это не получилось — попытаться как GD. Если и это не сработало — значит, формат вообще нераспознанный, обнуляем все реквизиты.

Три попытки, одна из них точно сработает (если формат — один из трёх известных). Логично же.

Логично, пока всё хорошо. Когда что-то идёт не так, эта конструкция превращается в чёрный ящик с проглоченными исключениями, и любая отладка становится археологией.

Симптом: реквизиты пустые, файл корректный

На прод пришла жалоба: оператор импортирует ГТД, файл загружается без ошибок, но реквизиты партии в карточке остаются пустыми. Сумма ноль, поставщик пустой, страны не заполнены. При этом сам файл выглядит нормально — открывается в браузере, валидируется по схеме, в нём явно есть всё нужное.

Я взял тот же файл, прогнал через парсер в отладке. Прошёлся по строкам. Всё ровно так: пустые реквизиты на выходе.

Открыл XML глазами. Корневой элемент — Declaration. То есть формат "первый", тот самый, который в каскаде стоит первой попыткой. Должен был отработать первой же веткой, без всяких альтернатив.

Включил вывод исключения внутри блока Исключение (там, где раньше его никто не выводил, потому что зачем — всё же "и так понятно"). Стал смотреть, что именно ловится. Текст исключения был такой: "Поле объекта недоступно для чтения: SellerName". Поле SellerName в этом конкретном файле было опущено. Это допустимо схемой ГТД — поставщик может отсутствовать в некоторых типах деклараций. И именно из-за этого опущенного поля каскад уходил в первое Исключение, проваливался во вторую попытку, не находил GDCGoodsShipmentDetails вообще, ловил исключение, проваливался в третью, не находил GDGoodsShipmentDetails, ловил исключение, обнулял всё.

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

Каскад Попыток: одно отсутствующее поле выбрасывает уже прочитанные значения и проваливает весь блок в следующую альтернативу

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

Почему вообще нельзя использовать Попытку для ветвления

Главная проблема каскада из Попытка/Исключение в том, что он смешивает два совершенно разных намерения в одной конструкции:

  1. Намерение "проверить, какой из вариантов подходит" — это ветвление. Должно реализовываться через явный Если/Иначе.
  2. Намерение "обработать неожиданную ошибку" — это обработка исключения. Должно реализовываться через Попытка/Исключение, но узко, вокруг конкретной операции, где ошибка ожидаема.

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

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

Я бы сформулировал это как принцип: исключение — это плохая навигация, потому что оно не показывает направление. Когда ты пишешь Если, ты явно говоришь "я проверяю условие X". Когда ты пишешь Попытка, ты говоришь "я готов к тому, что что-то пойдёт не так, но не уточняю что". Если использовать второе вместо первого, ты делаешь читателя кода (и себя через полгода) слепым.

Решение: Свойства().Получить() вместо каскада

В XDTO есть прямой способ узнать, существует ли свойство в объекте, без всяких исключений. У объекта XDTO есть метод Свойства(), который возвращает коллекцию свойств. Из этой коллекции можно методом Получить() взять конкретное свойство по имени, и если его нет — метод вернёт Неопределено, а не исключение.

То есть весь каскад из трёх Попыток заменяется на одну явную проверку:

СвойстваObjekta = ОбъектXDTO.Свойства();

Если СвойстваObjekta.Получить("DeclarationGoodsShipmentDetails") <> Неопределено Тогда
    КорневойУзел = ОбъектXDTO.DeclarationGoodsShipmentDetails;
ИначеЕсли СвойстваObjekta.Получить("GDCGoodsShipmentDetails") <> Неопределено Тогда
    КорневойУзел = ОбъектXDTO.GDCGoodsShipmentDetails;
ИначеЕсли СвойстваObjekta.Получить("GDGoodsShipmentDetails") <> Неопределено Тогда
    КорневойУзел = ОбъектXDTO.GDGoodsShipmentDetails;
Иначе
    Сообщить("Не удалось определить формат ГТД: "
        + "корневой элемент не Declaration, не GDC и не GD.");
    Возврат;
КонецЕсли;

Шесть строк вместо тридцати, и читается как естественный язык. Никаких исключений в хорошей ветке выполнения. Если файл вообще не подходит ни под один из трёх форматов — оператор получает понятное сообщение, а не молча заполненную пустотой карточку. Если файл подходит — переменная КорневойУзел ссылается на нужный поддерева.

Дальше реквизиты читаются по одному, и каждое чтение оборачивается в собственную проверку — отдельно сумма, отдельно валюта, отдельно поставщик. Если поставщик не указан в файле — это нормально, реквизит остаётся пустым, остальные читаются. Каждое поле — отдельный блок, и одно отсутствующее поле не отменяет правильно прочитанные соседние.

// Сумма — обязательное
Сумма = КорневойУзел.GoodsValue;
Валюта = КорневойУзел.CurrencyCode;

// Поставщик может отсутствовать
Если КорневойУзел.Свойства().Получить("SellerName") <> Неопределено Тогда
    Поставщик = КорневойУзел.SellerName;
КонецЕсли;

// Страны — могут отсутствовать каждая по отдельности
Если КорневойУзел.Свойства().Получить("OriginCountry") <> Неопределено Тогда
    СтранаИзготовления = КорневойУзел.OriginCountry;
КонецЕсли;

Получился код, в котором каждое решение — явное. "Если поставщик есть — прочитать. Если нет — оставить пустым". Не нужно гадать, что произошло, и не нужно копаться в проглоченных исключениях.

Замена каскада из Попыток на явные проверки через Свойства().Получить() для XDTO в 1С

Бонусом нашёлся ещё один тихий баг

Пока я возился с парсером, рядом обнаружилась вторая молчаливая поломка. Та же кнопка "Добавить файл ГТД" в карточке партии при нажатии на ещё несохранённом элементе справочника спрашивала пользователя: "Записать?". Пользователь соглашался. Элемент записывался. И ничего не загружалось. Файл, который он только что выбрал на диске, не появлялся в списке вложений.

Открыл обработчик ответа на вопрос "Записать?". И увидел, что внутри он вызывал не функцию загрузки ГТД, а функцию загрузки изображений. Просто copy-paste с соседней кнопки "Добавить картинку" из той же формы. Кто-то когда-то клонировал кнопку, изменил название и подпись, но забыл изменить функцию загрузки в обработчике подтверждения. В результате на одну кнопку висели две разные операции: "загрузить ГТД" вызывалась, если объект уже сохранён, и "загрузить картинку" вызывалась, если объект не был сохранён.

Картинки в выбранном файле не было, потому что это был XML, поэтому загрузка картинки молча проваливалась. Никаких сообщений, никаких ошибок. Оператор соглашался на запрос "Записать?", элемент записывался, и больше ничего не происходило. Никакого фидбэка о том, что только что нажатая кнопка не сделала ничего из того, что обещала.

Это, кстати, ещё одно проявление того же общего класса проблем. Молчаливая обработка ошибки — будь то проглоченное исключение, copy-paste-баг или "невидимая" регистрация в плане обмена — даёт пользователю ложное впечатление, что система делает то, что обещает. Я ровно про этот класс багов писал в статье про интеграции, которые ломаются не там, где ждёшь, и в истории про двойную негацию количества: оба случая — про код, который "работал", потому что все его молчаливые отказы выглядели как нормальное поведение.

Когда Попытка/Исключение всё-таки уместна

Чтобы этот текст не превратился в обвинение конструкции Попытка/Исключение как таковой, я хочу зафиксировать обратную сторону. Эта конструкция нужна и полезна. У неё есть законное место — но узкое.

Она хороша вокруг операций, которые могут упасть по причинам, не зависящим от твоего кода. Это HTTP-запросы к внешним сервисам, чтение файлов, запросы к базе на чтение, операции с COM-объектами, парсинг данных от ненадёжных источников, попытки сериализации/десериализации с непроверенным форматом. Везде, где сбой возможен и не контролируется тобой — Попытка/Исключение уместна.

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

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

А вот для чего она не нужна:

  • Для проверки существования свойства объекта — есть Свойства().Получить() для XDTO, СодержитЗначение() для документов, Метаданные().НайтиПоИмени() для метаданных.
  • Для проверки наличия записи в регистре — есть Получить() или прямой запрос с условием.
  • Для определения типа значения — есть ТипЗнч() и Тип().
  • Для перебора альтернатив "какой формат файла подходит" — есть явные проверки структуры данных.
Когда Попытка/Исключение уместна, а когда лучше явная проверка через Свойства() и Получить()

Финал

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

Замена на Свойства().Получить() сделала код короче, понятнее и, главное, способным сообщать о реальных проблемах. Если файл нераспознанный — пользователь получает явное сообщение. Если поле отсутствует — оно остаётся пустым, остальные читаются. Если в файле какая-то совершенно неожиданная структура — исключение всё-таки выбросится, но в одном конкретном месте, и его текст будет читаться целиком, а не проглатываться вторым уровнем каскада.

Я с тех пор стараюсь следить за собой: каждый раз, когда руки сами тянутся написать Попытка, я задаю себе вопрос — "Я обрабатываю ошибку или я выбираю между альтернативами?". Если второе — пишу Если, и обычно нахожу способ проверить условие явно, без обращения к механизму исключений. И если получается — почти всегда код становится понятнее, а молчаливых багов — меньше.

Исключение — это не оператор перехода. Это сигнал о том, что что-то пошло не так. Когда сигнал начинает использоваться для навигации, он перестаёт сигнализировать. И тогда любая реальная проблема растворяется в фоне обычной "работы" такого кода.