Как сделать процедуру доступной в разных модулях 1с

Обновлено: 07.07.2024

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

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

Общие модули;
Модули объектов (модуль объекта, модуль менеджера и т.п.) для всех типов объектов;
Модуль сеанса;
Модуль управляемого приложения;
Модуль внешнего соединения;
Модули команд;
Модули форм;
и т.д.

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

Здесь и дальше, чтобы вам было проще читать, вместо словосочетания «процедура/функция» мы будем использовать слово «метод». Итак, все изменения, которые вы можете выполнять в модулях, можно разделить на 4 группы:

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

Собственные обработчики
Вы можете добавлять собственные обработчики событий типовой конфигурации. Если, например, в типовой конфигурации они не назначены.

Собственные модули
Вы можете создавать в расширении собственные общие модули.

Вызов
И, наконец, вы можете вызывать в своём расширении любые методы типовой конфигурации.

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

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

Перехват вызовов методов

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

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

Аннотация &Перед("Процедура1") означает, что перехватывается типовая процедура с именем Процедура1. Имя аннотации Перед означает, что сначала будет выполнена ваша процедура-перехватчик Расш_Проц1(), а затем - типовая Процедура1().

В настоящий момент мы добавили в платформу три возможных имени аннотаций.

Аннотация &Перед

Аннотация с таким именем означает, что ваш перехватчик будет выполнен до того, как начнётся выполнение типового метода.

На схеме типовой и расширяющий модули показаны прямоугольниками, а стрелка показывает последовательность исполнения встроенного языка.

Аннотация &После

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

Аннотация &Вместо

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

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

&Перед;
&После;
&Вместо;
&Перед и &После.

Последняя комбинация перехватчиков (&Перед и &После) будет исполняться следующим образом:

Если же вы перехватываете типовую функцию, а не процедуру, то вы можете использовать только перехватчик &Вместо.

Вызов метода, перекрытого аннотацией &Вместо

Получается некоторая несправедливость. Процедуру вы можете перекрыть или обрамить. А функцию – только полностью перекрыть.

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

На встроенном языке такая функция-перехватчик может выглядеть следующим образом:

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

Метод ПродолжитьВызов() вы можете использовать не только при перекрытии функций, но и при перекрытии процедур. В этом случае результат его применения будет по смыслу такой же, как при использовании пары перехватчиков &Перед и &После. Разница будет лишь в том, что в этом случае ваша часть «до» и ваша часть «после» будут существовать внутри одного контекста. В некоторых ситуациях это может быть удобно. На встроенном языке такая процедура-перехватчик может выглядеть следующим образом:

Что лучше, &Перед, &После или &Вместо?

Когда вы перехватываете методы типовой конфигурации, всегда полезно помнить о двух вещах:

После того, как вы написали своё расширение, типовая конфигурация будет изменяться;
Ваша цель – добавить свою функциональность, а не навсегда отказаться от того, что есть, и что будет в типовой конфигурации.

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

Также вполне приемлемым является использование перехватчика &Вместо и метода ПродолжитьВызов(). Однако тут у вас появляется возможность и соблазн вызывать типовой метод не всегда, а в зависимости от каких-то своих собственных условий. К этому нужно подходить осторожно и помнить, что в тот момент, когда вы отказываетесь от вызова типового метода, вы отказываетесь от вызова не только того метода, который есть в конфигурации сейчас, но и от всех его вариантов, которые появятся в будущем. А в будущем, например, в нём могут появиться важные и полезные изменения.

И, наконец, самый «нехороший» вариант – это полное перекрытие типового метода перехватчиком &Вместо. В этом случае типовой обработчик безусловно не будет выполняться ни сейчас, ни в будущих версиях. То есть всю ответственность за работу будущих версий конфигурации вы берёте на себя, на своё расширение. Наверняка есть ситуации, когда такое полное перекрытие необходимо, но мы призываем вас подходить к его использованию очень взвешенно и осторожно.

Последовательность вызовов при перехвате методов

Здесь, прежде чем рассказывать, необходимо сделать небольшое пояснение. Важной, можно сказать, «идеологической» характеристикой расширений является их автономность. То есть расширения должны проектироваться так, чтобы не зависеть друг от друга.

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

Когда вы подключаете расширения к типовой конфигурации, образуется «многослойный пирог». В основании этого пирога находится типовая конфигурация, а на его вершине – последнее подключенное расширение.

Что в конфигураторе, что в режиме 1С:Предприятие, последнее подключенное расширение находится в списке последним.

Таким образом, в этом примере внизу находится типовая, наверху находится Расширение2, а между ними – Расширение1. Каждое следующее расширение перехватывает (расширяет) то, что находится под ним.

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

Пример 1

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

Сначала будет вызван перехватчик из Расширения2, потому что оно сверху. Это будет перехватчик &Перед, потому что у него такая аннотация;
Затем будет вызван перехватчик из Расширения1, потому что оно следующее в пироге. Это будет снова &Перед, потому что у него такая аннотация;
После этого будет вызван типовой метод, потому что больше нет перехватчиков, препятствующих его исполнению;
Затем, в обратной последовательности «пирога», будут вызваны перехватчик &После из Расширения1 и перехватчик &После из Расширения2.

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

Пример 2

Если в перехватчиках используется метод ПродолжитьВызов(), то действует тот же самый принцип «пирога».

Сначала будет вызван перехватчик из Расширения3, потому что оно сверху. Это будет перехватчик &Вместо, потому что у него такая аннотация;
При попытке вызвать типовой метод, будет анализироваться оставшийся «пирог». Анализироваться он будет точно таким же образом, как было описано в предыдущем примере;
В результате исполнение кода вернётся в перехватчик &Вместо, а по его завершении – в типовую конфигурацию.

Пример 3

Важным для понимания моментом является тот факт, что при перекрытии с помощью аннотации &Вместо, по факту перекрывается не только вызов основного метода, но также и перехватчиков, находящихся ниже в «пироге».

В этом примере будет выполнен только перехватчик &Вместо из Расширения2. Потому что он перекрывает собой типовой метод, то есть весь «пирог», который находится под ним.

Пример 4

Это, по сути, вариация на тему второго примера, но когда под верхним расширением находится расширение, также «прокидывающее» вниз вызов типовой процедуры.

По сути, он просто лишний раз визуализирует тот факт, что вызов типового метода относится ко всему «пирогу», находящемуся под расширением. Именно поэтому после вызова перехватчика из Расширения2, будет вызван перехватчик из Расширения1. Потому что в оставшемся «пироге» именно он перекрывает вызов типового метода, до которого хочется «дотянуться» Расширение2.

Перехват обработчиков событий и собственные обработчики в модулях объектов, менеджеров и т.п.

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

Во-первых, в качестве имени перехватываемого метода указывается имя события. Например, ПередЗаписью:

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

Поскольку в модулях объектов обработчики событий имеют фиксированные имена, а перечень аннотаций известен, мы реализовали для вас небольшой «сервис». При создании в расширении обработчика открывается диалог, в котором вы можете выбрать тип вызова. После чего в модуле создаётся заготовка процедуры-перехватчика.

Перехват обработчиков событий и собственные обработчики в модулях форм

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

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

Внешне перехватчик события в модуле формы выглядит следующим образом:

То есть аннотация не используется, а тип перехватчика указывается в палитре свойств. Делается это довольно просто. При создании в расширении обработчика по кнопке «лупа» открывается диалог. Он позволяет вам, помимо контекста, указать тип перехватчика (Перед, После или Вместо).

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

Если вы перекрываете типовой обработчик (Вместо), то это будет просто точка.

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

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

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

Прежде все модули, расширяющие модуль формы, и сам модуль формы, находились в одном пространстве имён. Таким образом, существовала возможность из верхнего расширения вызывать не только методы типовой конфигурации, но и методы лежащих ниже расширений. Теперь мы эту «лазейку» закрыли, и методы лежащих ниже расширений больше недоступны. Теперь вы можете обращаться только к методам, содержащимся в том типовом модуле, который вы расширяете.

Общие модули

В расширении вы можете создавать любые собственные общие модули. Существует только два ограничения:

Они не должны быть глобальными серверными;
Они не должны быть привилегированными.

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

Нельзя заимствовать глобальные серверные модули;
Код из вашего расширения будет исполняться только в непривилегированном режиме (если иное не разрешено в профиле безопасности).

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

Серверные методы расширяются не всегда

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

Если прикладное решение работает в файловом варианте или в клиент-серверном варианте без профилей безопасности, то при подключении вашего расширения:

В обычном режиме исполнения встроенного языка - будут расширяться все методы типового решения, и клиентские, и серверные;
В безопасном режиме исполнения встроенного языка - будут расширяться только клиентские методы и серверные обработчики форм. К остальным серверным процедурам / функциями расширение применяться не будет.

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

Для этого в профиль безопасности мы добавили несколько новых свойств.

Самое простое из них – это флажок к расширению всех модулей в группе Разрешен полный доступ. Он «одним махом» разрешает расширение серверного контекста.

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

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

При выполнении оператора Возврат процедура заканчивается и возвращает управление в точку вызова. Если в тексте процедуры не встретился оператор Возврат , то после выполнения последнего исполняемого оператора происходит выполнение неявного оператора Возврат . Конец программной секции процедуры определяется по оператору КонецПроцедуры .

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

Имя_проц	Назначает имя процедуры.
Знач	Необязательное ключевое слово, которое указывает на то, что следующий за ним параметр передается по значению, то есть изменение значения формального параметра при выполнении процедуры никак не повлияет на фактический параметр, переданный при вызове процедуры. Если это ключевое слово не указано, то параметр процедуры передается по ссылке, то есть изменение внутри процедуры значения формального параметра приведет к изменению значения соответствующего фактического параметра.
Парам1 , . ПарамN	Необязательный список формальных параметров, разделяемых запятыми. Значения формальных параметров должны соответствовать значениям передаваемых при вызове процедуры фактических параметров. В этом списке определяются имена каждого из параметров так, как они используются в тексте процедуры. Список формальных параметров может быть пуст.
= ДефЗнач	Необязательная установка значения параметра по умолчанию. Параметры с установленными значениями по умолчанию можно располагать в любом месте списка формальных параметров.
Экспорт	Необязательное ключевое слово, которое указывает на то, что данная процедура является доступной из других программных модулей.
// Объявления локальных переменных	Объявляются локальные переменные, на которые можно ссылаться только в рамках этой процедуры.
// Операторы	Исполняемые операторы процедуры.
Возврат	Необязательное ключевое слово, которое завершает выполнение процедуры и осуществляет возврат в точку программы, из которой было обращение к процедуре. Использование данного оператора в процедуре не обязательно.
КонецПроцедуры	Обязательное ключевое слово, обозначающее конец исходного текста процедуры, завершение выполнения процедуры. Возврат в точку, из которой было обращение к процедуре.

Функция

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

Функции отличаются от процедур только тем, что возвращают Возвращаемое значение . Конец программной секции функции определяется по оператору КонецФункции .

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

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

Использование переменных в программных модулях

Область применения: управляемое приложение, мобильное приложение, обычное приложение.

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

Примеры некорректного использования и исключений из этого правила приведены далее. Рекомендации по оформлению переменных в коде программных модулей см. в статье Структура модуля.

2. Неоправданные примеры использования переменных в модулях объектов (справочников, документов, наборов записей, обработок, отчетов и пр.).

2.1. Для передачи параметров между обработчиками подписок на события и в обработчики событий модуля объекта из внешнего кода рекомендуется использовать свойство объекта ДополнительныеСвойства . Например, неправильно:

Перем КонвертацияФайлов Экспорт;

Если КонвертацияФайлов Тогда
.

// вызывающий код
ФайлОбъект.КонвертацияФайлов = Истина;
ФайлОбъект.Записать();

Если ДополнительныеСвойства.Свойство("КонвертацияФайлов") Тогда
.

// вызывающий код
ФайлОбъект.ДополнительныеСвойства.Вставить("КонвертацияФайлов", Истина);
ФайлОбъект.Записать();

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

Перем ПредыдущееЗначениеОрганизации; // значение реквизита "Организация" до записи объекта в базу

Процедура ПередЗаписью(Отказ)
ПредыдущееЗначениеОрганизации = . ; // с помощью запроса выясняем значение до записи объекта в базу
КонецПроцедуры

Процедура ПриЗаписи(Отказ)
Если ПредыдущееЗначениеРеквизита <> Организация Тогда
// отрабатываем изменение значения реквизита при записи
.
КонецЕсли;

2.2. Для обработки кодов возврата (ошибок) в логике программного модуля рекомендуется использовать строковые константы.
Например, неправильно:

Перем НетОшибок,
Ошибка_ОбработкиПроверкиЗаполнения, // возникает, если обработка проверки заполнения вернула отказ
Ошибка_ЗаписиОбъекта, // возникает, если во время записи объекта возникло исключение
Ошибка_БлокировкиОбъекта, // возникает, при попытке блокировки объекта

Процедура ВыполнитьПерерасчет()
.
Результат = ОбработатьДокументы(. );
Если Результат = Ошибка_ЗаписиОбъекта Тогда
.
ИначеЕсли Результат = Ошибка_БлокировкиОбъекта Тогда
.
ИначеЕсли .

НетОшибок = 1;
Ошибка_ОбработкиПроверкиЗаполнения = 2;
Ошибка_ЗаписиОбъекта = 3;
Ошибка_БлокировкиОбъекта = 4;

Процедура ВыполнитьПерерасчет()
.
Результат = ОбработатьДокументы(. );
Если Результат = "ОшибкаЗаписиОбъекта" Тогда
.
ИначеЕсли Результат = "ОшибкаБлокировкиОбъекта" Тогда
.
ИначеЕсли .

2.3. Для кеширования долго-вычисляемых и часто-используемых значений в процедурах и функциях рекомендуется применять модули с повторным использованием возвращаемых значений на время вызова сервера.

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

3. Неоправданные примеры использования переменных в модулях форм.

3.1. Для кеширования долго-вычисляемых и часто-используемых значений в процедурах и функциях рекомендуется применять модули с повторным использованием возвращаемых значений.

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

3.2. Для хранения и передачи промежуточных результатов вычислений между разными процедурами и функциями формы следует использовать

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

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

&НаКлиенте
Перем ПорядковыйНомерИзображения; // счетчик-нумератор для наименования файлов при сканирования нескольких изображений
.
&НаКлиенте
Процедура ВнешнееСобытие(Источник, Событие, Данные)
Если Источник = "TWAIN" И Событие = "ImageAcquired" Тогда
Если ПорядковыйНомерИзображения = Неопределено Тогда
ПорядковыйНомерИзображения = 1;
КонецЕсли;
ПорядковыйНомерИзображения = ПорядковыйНомерИзображения + 1;
// Сохранение отсканированного документа в файл с номером ПорядковыйНомерИзображения
// .
КонецЕсли;
КонецПроцедуры

4. Переменные управляемого и обычного приложения следует использовать для хранения «клиентских параметров сеанса». Подробнее см. статью Использование параметров сеанса.

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

Кроме того, в параметрах сеанса не получается хранить сложные объекты, типа COM-объектов (в том числе из внешних компонент), обработок и др.

В некоторых случаях будет полезным следующий трюк:

В конфигурации создается обработка, которая обеспечивает доступ к модулю приложения из общего модуля.

В модуле обработки (не путать с модулем формы) размещаются следующие процедуры и функции:

Теперь в процедурах и функциях общих модулей можно делать следующие вещи:

Я думаю, вы выясните самостоятельно, как передавать параметры в процедуры и функции.

Еще хочу заметить, что такая обработка представляет собой ДЫРУ В БЕЗОПАСНОСТИ, потому что позволяет выполнить произвольный программный код и вызвать любую процедуру или функцию модуля приложения и общих модулей.

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

Кроме того, обращение к глобальным переменным будет довольно накладным (требуется создание объекта ОбработкаОбъект), но целью данной статьи является демонстрация технологических возможностей платформы на принципах "AS-IS". Вся ответственность за ваши программы лежит на вас.

Рекомендуется по возможности:
1. Обходиться вообще без глобальных переменных
2. Передавать информацию через параметры процедур и функций
3. Использовать параметры сеанса
4. Не допускать выполнения чужого программного кода
5. Комментировать сложные участки программы

Альтернативное решение, посредством общей формы вместо обработки

Недостаток вышеприведенного метода - в каждой функции общего модуля нужно создавать экземпляр обработки.
Реализация: :
Если есть общая-рабочий стол, то используем её, иначе создаем новую "ТестоваяФорма". На форму кладем ПолеВвода "рез" составного типа данных, и если форма-рабочий_стол,- то ещё два поляВвода "выражение_" и "парам".
В модуль формы кладем код

В модуль приложения

Пример использования
(не забудьте ф = ПолучитьОбщуюФорму("ТестоваяФорма", ,"ТестоваяФорма") в каждом модуле)

для формы, которая рабочий стол

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

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

Строка . СуммаСтроки = Строка . КоличествоСтроки * Строка . ЦенаСтроки ;

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

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

//обработчик вызываемый при изменении количества в строке табличной части

Вызов общего модуля

В свойствах общего модуля установим флаг Клиент:

В самом модуле добавим следующий код:

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

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

Клиентский общий модуль

Если в свойствах общего модуля установлен только флаг Клиент, то к методам такого модуля можно будет обращаться только на клиенте. Из самого общего модуля можно выполнять вызов экспортных методов модуля приложения.

Серверный общий модуль

Если установлен только флаг Сервер, то к методам такого модуля можно будет обращаться только на сервер.

Вызов сервера

При установленных двух флагах Сервер и Вызов сервера к методам модуля можно обращаться как на клиенте, так и на сервере. Но само выполнение методов будет выполнено на сервере.

Клиент-серверный общий модуль

У такого общего модуля в свойствах нужно установить и флаг Клиент и флаг Сервер.

Чтобы при компиляции такого общего модуля не было ошибок нужно с помощью инструкций препроцессора разделить процедуры на клиентские и серверные:

Вызывать серверные методы общего модуля можно только на сервере:

//чтобы вызвать серверный метод нужно перейти на сервер

Глобальный общий модуль

Если в свойствах модуля поставить флаг Глобальный, то для вызова методов общего модуля не нужно указывать имя общего модуля.

Глобальные общие модули будут скомпилированы при запуске конфигурации.

Привилегированный общий модуль

Общий модуль с таким флагом всегда выполняется без проверки прав доступа. Такой общий модуль может быть только серверным.

Повторное использование возвращаемых значений

Использование данного свойства позволяет сохранять в кеше параметры и результат функций. Работает только для функций в неглобальных общих модулях.

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

Есть два варианта повторного использования возвращаемых значений:

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

Если в рабочем процессе сервера 1С не хватает оперативной памяти
Рабочий процесс был перезапущен
Клиент был переключен на другой рабочий процесс
Прошло 20 минут после сохранения или 6 минут после последнего использования
Если вызвать метод ОбновитьПовторноИспользуемыеЗначения

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

Для сохранения в кеше и повторного использования можно использовать параметры следующих типов:

Читайте также: