Написал такую процедуру.

Процедура ПриОтправкеДанныхПодчиненному(ЭлементДанных, ОтправкаЭлемента, СозданиеНачальногоОбраза)
   
   Если Строка(ТипЗнч(ЭлементДанных)) = "Справочник объект: Физические лица" Тогда
       
       ОтправкаЭлемента = Обмен.ПроверитьОтправку(Ссылка, ЭлементДанных, ЭлементДанных.НаселенныйПункт.Район);
       
   ИначеЕсли Строка(ТипЗнч(ЭлементДанных)) = "Справочник объект: Населенные пункты" Тогда
       
       ОтправкаЭлемента = Обмен.ПроверитьОтправку(Ссылка, ЭлементДанных, ЭлементДанных.Район);
       
   ИначеЕсли Строка(ТипЗнч(ЭлементДанных)) = "Справочник объект: Районы" Тогда
       
       ОтправкаЭлемента = Обмен.ПроверитьОтправку(Ссылка, ЭлементДанных, ЭлементДанных.Ссылка);
       
   ИначеЕсли Строка(ТипЗнч(ЭлементДанных)) = "Справочник объект: Сельсоветы" Тогда
       
       ОтправкаЭлемента = Обмен.ПроверитьОтправку(Ссылка, ЭлементДанных, ЭлементДанных.Район);
       
   ИначеЕсли Строка(ТипЗнч(ЭлементДанных)) = "Регистр сведений набор записей: Штрихкоды" Тогда
       
       ОтправкаЭлемента = Обмен.ПроверитьОтправку(Ссылка, ЭлементДанных, ЭлементДанных.Отбор.Владелец.Значение.НаселенныйПункт.Район);
       
   ИначеЕсли Строка(ТипЗнч(ЭлементДанных)) = "Регистр сведений набор записей: Фамилия, имя, отчество физического лица" Тогда
       
       ОтправкаЭлемента = Обмен.ПроверитьОтправку(Ссылка, ЭлементДанных, ЭлементДанных.Отбор.ФизЛицо.Значение.НаселенныйПункт.Район);
       
   ИначеЕсли Строка(ТипЗнч(ЭлементДанных)) = "Регистр сведений набор записей: Состояние" Тогда
       
       ОтправкаЭлемента = Обмен.ПроверитьОтправку(Ссылка, ЭлементДанных, ЭлементДанных.Отбор.ФИО.Значение.НаселенныйПункт.Район);
       
   КонецЕсли;
   
КонецПроцедуры


Думаю, что есть более простой вариант, чем 6 раз использовать ИначеЕсли. Причем объектов будет больше и условий соответственно тоже.

(0) Нормально так ты на тонком клиенте херачишь...

(0) ты в субботу вечером хочешь помощи или чтобы постебались?

Можно оптимизировать.
Смотреть в сторону массивов/таблиц значений/соответствий и т.д.

А что с типом Тип нельзя сравнивать? Обязательно строки мучать?

>>Строка(ТипЗнч(ЭлементДанных)) = "Справочник объект: Физические лица"


уже пять:-)
Читай радчеко чтоли.

(1) поделись мудростью: по такому коду как тип клиента определить?:)

(2) это более продвинутые уровни.

(1) Тонкий

(4) Какая разница что сравнивать. Вопрос совсем другой

(5) -> (6) Вот видишь! :-))

ЗЫ: Не поделюсь! :-Р

(2) Построение массива/таблицы значений/соответствия - займёт не меньше времени, чем подобный перебор. IMHO.

(0) "Лучшее - враг хорошего". Детали разве что можешь подрихтовать.

Если б был оператор типа case of

(7) ИначеЕсли нормальное решение, надо оптимизировать выражения

(7)Действиельно..Какая разница? Ну и живи дураком.

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

(12) Я думаю если сравнивать объекты метаданных а не строки - это на скорости никак не отразится

(12)Вопрос спорный. Сам не мерил..Так что.

(9) т.е. предлагаешь при каждом вызове процедуры заново отстраивать...
Эх... Кто придумывал кэширование данных тебя не послушались. Дураки.

(11) В ассемблере по тактам не оптимизировал код:)

(15)->(14)

(0) еще можно вынести расчет выражения Строка(ТипЗнч(ЭлементДанных)) за блок "Если", то будет оптимальнее.

Процедура ПриОтправкеДанныхПодчиненному(ЭлементДанных, ОтправкаЭлемента, СозданиеНачальногоОбраза)
   ячячяч = Строка(ТипЗнч(ЭлементДанных))
   Если ячячяч = "Справочник объект: Физические лица" Тогда
       
       ОтправкаЭлемента = Обмен.ПроверитьОтправку(Ссылка, ЭлементДанных, ЭлементДанных.НаселенныйПункт.Район);
       
   ИначеЕсли ячячяч = "Справочник объект: Населенные пункты" Тогда
       
       ОтправкаЭлемента = Обмен.ПроверитьОтправку(Ссылка, ЭлементДанных, ЭлементДанных.Район);
...............

(18)много грибов съел перед этим?

(19) ну съел немного шампиньонов, а что?

(20)Заметно

(16) Что именно "заново отстраивать"? Чем будешь это соответствие/таблицу заполнять - для данного случая? Когда у него то ЭлементДанных.НаселенныйПункт.Район, то ЭлементДанных.Отбор.ФизЛицо.Значение.НаселенныйПункт.Район?

(21) чем?

(18) думать не хочется, но еще на ступеньку оптимальней будет
Выполнить(НекаяКоллекция[ячячяч])

(24) Выполнить - разве что затормозит.

ну вы тут поспорьте, ребята, я пока за пивом схожу.  Чуется мне будут общие темы.

-20 минут

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

Процедура ПриОтправкеДанныхПодчиненному(ЭлементДанных, ОтправкаЭлемента, СозданиеНачальногоОбраза)
   зщзщ = Строка(ТипЗнч(ЭлементДанных))
   ячячяч = Новый Соответствие();
   ячячяч["Справочник объект: Физические лица"] = ЭлементДанных.НаселенныйПункт.Район;
   ячячяч["Справочник объект: Населенные пункты"] = ЭлементДанных.Район;
   ячячяч["Справочник объект: Районы"] = ЭлементДанных.Ссылка;
   ячячяч["Справочник объект: Сельсоветы"] = ЭлементДанных.Район;
........................
........................      
   ОтправкаЭлемента = Обмен.ПроверитьОтправку(Ссылка, ЭлементДанных, ячячяч[зщзщ] );
   
КонецПроцедуры

(29) Всё это строится при каждом вызове процедуры и наружу его не вынесешь.

(28) Оптимизируй проверяемые выражения.
А Если ... Тогда - работает достаточно быстро. И уж явно побыстрее всяких Выполнить, и уж тем более циклов по метаданным.

(30) ну и хрен с ним. Пусть будет. Зато красиво и без кучи ИначиЕсли

(32) И существенно тормознутее.

(29) Сразу выдаст ошибку. Если объект ФизЛицо и я напишу
ячячяч["Справочник объект: Населенные пункты"] = ЭлементДанных.Район; оно ругнеться что нет реквизита Район

(34) пропиши во все объекты реквизит .Район и присвой ему район который каждый раз в непонять где у тебя.

(34) У тебя в (0) - нормальный вариант. Только замени сравнение строк сравнением типов - и наступит счастье.

(35) Издеваешься?

(36) тогда лучше как (18)

(37) так не придется городить процедуру с перебором

(38) Тогда лучше ТипЗнч(...)=Тип(...) и не мучить строки.

(39) А что плохого в процедуре с перебором? В данном случае, IMHO, это как раз лучшее решение.

(40) Тип(...) быстрее выполняется чем константа строка?

(41) плохого в том что это перебор вместо прямого обращения к реквизиту.

(42) Не чем константа, а чем получение представления типа из типа и сравнение строк.

(44) представление типа вынимается всего один раз, а затем только строки сравниваются. Ты тоже грибы ел?

(43) Дык нет реквизита-то. У него ведь и ЭлементДанных.Отбор.Владелец.Значение.НаселенныйПункт.Район имеется. А всобачивать реквизиты повсюду ради одной (вспомогательной) процедуры - это как-то не интеллигентно.

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

Метаданные.Документы.Содержит() ... Строки изврат ...

(45) Один раз. Но - таки выполняется?
Ну и сравнение строк - нисколько не быстрее сравнения типов.

(46) почему не интеллигентно? Можно и всобачить если это поможет быстродействию.

(48) Таки да, примерно одинаково получается.
Что, думаешь "Выполнить" один раз будет медленнее чем несколько повторных сравнений?

(49) Посмотри в (0) - куда этот Район всобачивать придётся. И это ведь неполный список. И ведь Район надо будет заполнять. Так что выигрыша в быстродействии что-то не видать.

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

(50) Выполнить - конечно медленнее. Ему ведь разобрать свой параметр надо (каждый раз!) - а это не самый лёгкий труд. Сравнения же - уже скомпилированы.

(52) И правильно сделал! Ибо это - лучшее, что можно придумать. IMHO.

(51) Если ты не видишь выигрыша в быстродействии если всю процедуру заменить одним выражением, то спорить бесполезно.

(53) И во сколько раз выполнить медленнее одного сравнения?

(52) Воспользуйся хотябы советом (18) если оставляешь как есть

(56) А напиши хотя бы парсер хотя бы для простого арифметического выражения. И посмотри, во сколько раз медленнее.

В языках с нормальным ООП вся бы эта конструкция записалась как:
ОтправкаЭлемента = Обмен.ПроверитьОтправку(Ссылка, ЭлементДанных, ЭлементДанных.ПолучитьРайон());

И соответственно, каждый бы тип имел свою реализацию метода "ПолучитьРайон()"

(52) >> Решил оставить как есть.

рекомендацию из (18) все-таки лучше учесть

(59) кстати, да. Можно же в модуле объекта или его менеджера прописать процедуру к которой потом обращаться таким образом?