Введение

ООП - объектно-ориентированное программирование, является на сегодняшний день одной из самых популярных технологий создания программных средств. Данная разработка направлена на устранение недостатка отсутствия ООП в языке 1С. Как известно, ООП базируется на трех основных принципах: полиморфизм, наследование и инкапсуляция; в данной разработке для возможной технической реализации принципов, были добавлены некоторые языковые средства. Также добавлена возможность строгой проверки типов для параметров методов классов, определяемых пользователем (КОП) и некоторые другие классы для расширения парадигмы ООП.

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

• уменьшение зависимостей не связанных между собой логически частей учетной системы;
• уменьшение написания и тестирования кода для связанных между собой логически понятий объектов системы
• возможность расширения существующего функционала
• концентрирование кода алгоритма в одном программном модуле с четко определенным интерфейсом его использования, что позволит вносить изменения в алгоритм и осуществлять его исправление без необходимости проверки и исправления всего зависящего от него кода
• для разделения функционала на три логических уровня: уровень интерфейс пользователя, уровень бизнес-логики, уровень сохранения/получения (персистентность) результатов и объектов, другими словами - уровень взаимодействия с БД
• повторяемость кода или наследуемость кода базового класса его наследниками

В реализации наследования в ВК (внешней компоненте 1С:Предприятия) 1С++ необходимо определить следующий функционал:

• Возможность наследования классов от встроенных типов, таких как: "Справочник", "Документ" и т.д.
• Возможность наследования от типов, определяемых пользователем (классов 1С++)
• Возможность вызова переопределенных функций производными классами из функций базового класса
• Возможность переопределения функций базовых классов в классах наследниках
• Возможность вызова базовых функций из переопределенных функций наследуемого класса

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

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

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

Работа с компонентой

Функционал класса

Каждый класс, определенный пользователем (КОП), создается в 1С с помощью метода СоздатьОбъект(ИмяКласса).

Для каждого КОП определен стандартный интерфейс, состоящий из следующих методов:

//#if _NOW_PREPARE_CLASS
  // -- данные и методы класса
//#endif //_NOW_PREPARE_CLASS

//#if !_NOW_PREPARE_CLASS
  // -- данные и процедуры формы

  Процедура ПриОткрытии()
  // код открытия формы
  КонецПроцедуры
//#endif  //! _NOW_PREPARE_CLASS

Формат файла определения КОП

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

// - комментарий для программы
класс (class)  имя класса = имя файла класса реализации :
  <имя базового класса>, <имя базового класса> {
Объявления методов класса
};

имя класса

может состоять из любых печатных символов. Внимание! учитывается регистр имени.

имя файла

<Путь>|<#Псевдоним>Имя файла.* | Имя обработки@MD файл реализации класса, если не указан путь, расположенный в каталоге с файлом конфигурации текущей ИБ, в котором реализуются методы класса и определяются атрибуты. Путь может быть относительным и формируется всегда относительно пути расположения конфигурации ИБ, вне зависимости от текущей папки файловой системы. Если указан #Псевдоним пути, то данный псевдоним ищется в файле инициализации компоненты, который должен находиться в каталоге BIN 1С:Предприятия и называться oxy.ini. В данном файле необходимо создать раздел [alias_path], который содержит все псевдонимы путей.

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

Пример файла инициализации компоненты:

[alias_path]
Псевдоним1 = С:\Классы1С_1\
Псевдоним2 = С:\Классы1С_2\

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

класс МойКласс = #Псевдоним1\ Псевдоним1.ert {};

имя базового класса

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

объявление методов класса

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

функции:

<Тип возвращаемого значения> Имя функции (Val | Знач> Тип переменной <Имя переменной = Значение по умолчанию>, <Val | Знач> Тип переменной <Имя переменной>, ...);

процедуры:

void Имя процедуры (Val | Знач> Тип переменной Имя переменной = Значение по умолчанию, <Val | Знач> Тип переменной <Имя переменной>, ...);

Val | Знач

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

Любой тип - может быть заменен ключевым словом Неопределенный (Undefine), что отключает для данного параметравозвращаемого значения проверку типов. Типом может быть Справочник, что означает возможность передавать в параметр метода справичник любойго вида справочника, (аналогичное поведение для типов Документ, и Регистр, и т.п.) - смысл, аналогичный типу "Справочник" или ГрупповойКонтекст, когда типом параметра может быть контекст любого модуля. (обязательный)

Имя

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

Значение по умолчанию

задается после имени параметра и должно быть одного того же типа, что и тип для данного параметра. Возможные типы: Строка Пар1 = "Значение по умолчанию"; Число Пар1 = 100; Дата Пар1 = '01.01.2002', а также КОП и агрегатные объекты 1С:Предприятия задаются с заключением их в кавычки, например МойКласс ПарКласс = "МойКласс" - по умолчанию параметр ПарКласс будет содержать в теле метода значение экземпляра класса "МойКласс". Значением по умолчанию может быть простое выражение языка 1С, например - значения констант, перечислений, функций без параметров. Например, Дата дПарДата = РабочаяДата(), параметр "дПарДата" примет значение по умолчанию, возвращенное из метода РабочаяДата(). Внимание: при указании в качестве значения по умолчанию "" - тип значения не учитывается. Значения по умолчанию возможно задать только в последних параметрах метода. Также возможно задавать параметры по умолчанию прямо в модулях определения класса, а не в prm-файле, т.е. как в штатном 1С. Но есть ограничения: 1. Приоритет будет у определения в prm-файле 2. Для параметров, определенных в модулях классов, действуют штатные ограничения 1С на параметры по-умолчанию - например, нельзя использовать функции и т.д. 3. Методы с неопределенным числом параметров можно описывать только в прм-файлах.

Неопределенное количество параметров

метод, объявленный с параметром "...", может принимать любое количество параметров во время вызова. Параметры метода, которые определены стандартным образом, называются явными параметрами. Параметры, которые получены в ходе вызова метода в месте определения троеточия и далее за ним, называются неявными. Пример: void Метод1(Строка стрПар1, Число чПар2, ...);, где параметры стрПар1, чПар2 являются явными и при вызове метода в них обязательно необходимо передавать значения их типов. Пример вызова данного метода может выглядеть так: МойКласс.Метод1("{Пар3, Пар4, Пар5}", 200, "Значение параметра 3", "Значение параметра 4", "Значение параметра 5"); , где значения неявных параметров равны следующим строкам "Значение параметра 3", "Значение параметра 4", "Значение параметра 5", количество таких значений в нашем примере равно 3, но оно может быть любым и зависит только от потребностей алгоритма. И в то же время явные параметры стрПар1 и чПар2 в нашем примере, соответственно, получат значения "{Пар3, Пар4, Пар5}" и 200. В реализации метода "Метод1" необходимо написать процедуру со следующей сигнатурой: Процедура Метод(стрПар1, чПар2) //Тело процедуры КонецПроцедуры. Значения неявных параметров можно получить вызвав общий метод класса ПолучитьСписокПараметров (ИмяМетода) (GetParamsList(NameOfMethod)), который возвращает список значений, содержащий неявные значения параметров, переданных в метод. В одном из явных параметров Вы можете передать строку, заключенную в фигурные скобки ({}), и содержащую названия ключей, разделенных запятыми. Данные ключи сопоставляются с неявными параметрами в списке значений, которые в реализации метода класса можно получить, использовав метод списка "Получить(Строка)". В нашем примере таким строковым (явным) параметром является первый параметр метода "стрПар1", значение которого при вызове метода равно "{Пар3, Пар4, Пар5}", что означает - в списке значений неявных параметров содержатся значения "Значение параметра 3", строковый ключ которого равен "Пар3", следующее значение "Значение параметра 4", а ключ для него "Пар4" и т.д.

Примеры:

класс Базовый_1=Base_1.txt
{
  void Метод1(Число пар1, Строка пар2);
  Число Метод2(Число пар1, Дата пар2);
};
класс Производный_1=Derive_1.txt: Базовый_1, Справочник.Спр1, ТаблицаЗначений
{
  void Метод1(Число пар1, Строка пар2); // Данный метод переопределяет метод
    //базового класса
  Число КоличествоСтрок (Число Колич); // В данном случае мы переопределили
    //метод базового класса ТаблицаЗначений и добавили проверку типов. В реализации этого
    //метода можно переадресовать вызов базовому классу
  void Метод3(ОС ОС); // в этот метод мы должны передаем передавать КОП "ОС"
};
класс ОС=OC.txt : Справочник.ОсновныеСредства, Справочник.НематериальныеАктивы
{
  void Метод1(Базовый_1 пар1); // В данном случае в пар1 можно передавать
    //объекты типа "Базовый_1" и его производный класс "Производный_1"
  void Метод2(Производный_1 пар1); // в отличие от предыдущего случае в пар1 мы
    //можем передавать объекты типа "Производный_1", но не "Базовый_1"
  Число ВыбратьЭлементы(Число чРежим);
  Число ПолучитьЭлемент(Число чРежим);
};

Внимание: проверка типов может быть отключена по требованию пользователя, об этом см. ниже.

Формат файлов реализации КОП

// Реализация метода "Метод1" класса "Производный_1" см. предыдущий пример
Процедура Метод1 (пар1, пар2) Экспорт
  Базовый_1 = вирт().ПолучитьБазовыйКласс("Базовый_1");
  Если Базовый_1 <> 0 Тогда

  КонецЕсли;
КонецПроцедуры

Процедура Метод2 () Экспорт
  вирт().Метод1(1, 2);
КонецПроцедуры

// В начале каждого модуля приходится определять закрытую функцию для получения
// контекста. Поэтому лучше пользоваться вирт() !
Функция Этот(Конт) Возврат Конт; КонецФункции

// Реализация метода "Метод1" класса "Производный_1" см. предыдущий пример
Процедура Метод1 (пар1, пар2) Экспорт
  Конт = Этот(Контекст);
  Базовый_1 = Конт.ПолучитьБазовыйКласс("Базовый_1");
  Если Базовый_1 <> 0 Тогда

  КонецЕсли;
КонецПроцедуры

Перем Конт;
...............
Конт = вирт();
...............

Перем Конт;
Функция GetThis(Конт) Возврат Конт; КонецФункции
...............
Конт = GetThis(Контекст);
...............

class База = base.ert
{
        void Метод1(); // Этот метод мы не переопределяем, а вызываем здесь
                                                                          // Метод2 производного класса
        void Метод2();
};
class Производный = derive.ert : Тест14_База
{
        void Метод2(); // переопределяем метод базового класса
};

Процедура Метод2() Экспорт
        Сообщить("База::Метод2");
КонецПроцедуры
Процедура Метод1() Экспорт
        Сообщить("ТипзначенияСтр(Контекст) =
"+ТипзначенияСтр( вирт() )); // получаем название текущего класса
        вирт().Метод2(); // вызываем переопределенный метод
КонецПроцедуры

Процедура Метод2() Экспорт
        Сообщить("Производный::Метод2");
КонецПроцедуры

Сообщить("Создали Производный класс");
копПрозв = СоздатьОбъект("Производный");
копПрозв. Метод1();
Сообщить("Создали База класс");
копБаза = СоздатьОбъект("База");
копБаза. Метод1();

Создали Производный класс
Производный
Производный::Метод2
Создали База класс
База
База::Метод2

//# ClassBegin <ClassName1>;
Перем ПеременнаяКласса1;
Процедура Конструктор()
        .........
//# ClassEnd <ClassName1>;



//# ClassBegin <ClassName2>;
Перем ПеременнаяКласса2;
Процедура Конструктор()
        .........
//# ClassEnd <ClassName2>;

Препроцессор

Директивы препроцессора 1С++ могут быть в файлах объявления интерфейсов классов (Defcls.prm), в файлах реализации КОП и во всех модулях 1С, кроме модуля глобального модуля и модулей внешних обработок/отчетов. Символы препроцессора, объявленные в файле объявления класса, действительны в области видимости модулей реализации класса, т.е. доступны в файлах реализации КОП. Внимание: из-за раздельной интерпретации файла Defcls.prm и файлов реализации КОП изменения, определения и отключение символов препроцессора осуществляются независимо. Работа препроцессора гарантируется в следующей последовательности: сначала обрабатывается файл Defcls.prm, затем в неопределенной последовательности обрабатываются файлы реализации КОП.

//#if symbol [operator symbol]

Если символ определен, что равнозначно "истине", или символы, объединённые логическими операторами дают в результате "истину", то код, заключенный между директивами //#if и //#elif или //#else или //#endif, буден включен на выполнение. Symbol - это символ, который будет тестироваться на определенность ранее директивой //#define. Перед символом можно использовать знак ! (логическое отрицание). Operator:

=  (равно);
!=  (не равно);
&   (И);
\|   (ИЛИ);

тело с кодом, открытое директивой //#if, должно закрываться директивами //#elif , //#else, //#endif;

//#else

директива, тело которой получает управление, если выражение равно "ложь" в предшествующих ей директивах //#if или //#elif. Тело с кодом должно заканчиваться директивой //#endif;

//#elif symbol [operator symbol]

директива, управление на которую передается, если в предыдущих директивах //#elif и //#if была получена "ложь". Проверяются условия указанные symbol [operator symbol]... и, если получена "истина", код заключенный в блоке между //#elif, и следующим за ним директивой //#elif или #else или //#endif, включается в код модуля КОП. Описание symbol [operator symbol]... см. у директивы //#if;

//#define symbol

определяет символ условной компиляции, использование этого символа в условных директивах даст "истину", с условием отсутствия снятия этого символа ранее директивой //#undef;

//#undef symbol

убирает определенный ранее символ. Символ используется для условной интерпретации кода в директивах //#if, //#elif, //#else;

//#warning text

выводит "text" в окно сообщений 1С. Примечание: в Defcls.prm данная директива отключена;

//#error text

останавливает выполнение кода программы в этом месте с выводом "text" в окно сообщений 1С. Примечание: в Defcls.prm данная директива отключена;

//#preprocessor off

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

//#exinfo

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

#include "<#alias></pathname/>namefile.ext"

директива служит для вкладывания других файлов определений в основной файл проекта (ИБ) defcls.prm. В пути к файлу может быть использован псевдоним, определенный в oxy.ini, относительный путь или полный путь к файлу. Каталогом по умолчанию считается каталог ИБ. Расширение файла может быть txt, prm - обычные текстовые файлы и ert - модуль отчета 1С

#curmeth

директива выводит на экран текущий исполняемый метод класса и его параметры с актуальными значениями и типами в месте появления данной директивы. Примечание: в Defcls.prm данная директива отключена.

Отладка классов 1C++

Для отладки модулей классов необходимо выполнить следующие действия:

1. В настройках компоненты 1С++ нажать кнопку "Отладка;
2. Отладка возможна только для классов, хранящихся во внешних ert-файлах или встроенных в конфигурацию в виде обработок;
3. Если модуль класса расположен в текстовом файле, то следует сохранить его в модуле отчета;
4. Форма отчета, в котором хранится модуль класса, обязана иметь хотя бы один диалоговый элемент.

ВНИМАНИЕ: Рекомендуется в клиентском режиме 1С:Предприятия выключать режим "Отладки".

5. Возможна проблема: Глобальные объекты, созданные в режиме отладки, не дают закрыть 1С!

Например, если в глобальном модуле написано
  Перем глОбъект;
  Процедура ПриНачалеРаботыСистемы()
      ЗагрузитьВнешнююКомпоненту("1cpp.dll");
      // а теперь включить режим отладки
        глОбъект = СоздатьОбъект("КОП");
      // объект создан в режиме отладки, его отладочная форма видна на экране
  КонецПроцедуры  // ПриНачалеРаботыСистемы

  После запуска такой конфигурации в режиме отладки
  1С невозможно закрыть стандартными средствами :(

  К сожалению, не помогает и явный сброс объекта
  Процедура ПриЗавершенииРаботыСистемы()
      глОбъект = 0;
  КонецПроцедуры  // ПриЗавершенииРаботыСистемы
  До этой процедуры дело просто не доходит :(

  Простой вариант решения в этом случае - спец. обработка, обнуляющая все глобальные объекты

Настройка 1C++

Настройка компоненты осуществляется с помощью настройки параметров 1С, Сервис --> Параметры ... --> Закладка "Настройка 1C++". Данная закладка появляется только после загрузки компоненты методом 1С ЗагрузитьВнешнююКомпоненту.

На данной закладке присутствуют три флажка в виде кнопок: "Проверка типов" и "Оптимизация", "Отладка":

• Проверка типов включает строгую проверку типов во время выполнения кода, при этом несколько увеличивается время вызова метода, в финальной версии программного продукта рекомендуется отключать данную опцию;
• Оптимизация представляет собой метод "отложенных вычислений", который реализован в следующем виде: если в системе не разу не инстанцировался (создавался экземпляр КОП) класс, то его реализация (модуль КОП) не считывается с диска и не компилируется в P-код. При первом создании объекта КОП происходит считывание с диска модуля и его компиляция, далее откомпилированный модуль сохраняется в репозитории модулей КОП, и в последующих созданиях объектов этапы по считыванию с диска и компиляции не производятся. Данная оптимизация позволяет существенно уменьшить время создания объектов КОП, за счет увеличения объёма используемой памяти компьютера, что несущественно для данного вида оптимизации. Это режим рекомендуется включать в финальной версии продукта. При отключенной оптимизации при каждом создании объекта происходит считывание с диска и компиляция модуля КОП, что позволяет вносить изменения в модуль без закрытия/открытия 1С в режиме 1С:Предприятие. По аналогии с #LoadFromFile для модулей 1С.
• Отладка позволяет отлаживать в отладчике 1С модули классов, которые хранятся в модулях отчетов. В финальной версии программного продукта необходимо отключать данную опцию.