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

• DynamoRevit ссылается на сборки Dynamo, поэтому их следует создавать с соответствующими пакетами NuGet. Например, DynamoRevit 2.x не загружается в Dynamo 1.3.

• DynamoRevit относится к определенным версиям Revit, например ветвь DynamoRevit 2018 должна работать в Revit 2018.

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

• Revit 2023.

• Последняя версия DynamoRevit, созданная в ветви Revit2023.

• Последняя сборка Dynamo.

Для успешной сборки в этом руководстве мы клонируем репозитории Dynamo и DynamoRevit.

Примечание. Создавать Dynamo вручную до использования DynamoRevit требуется только при сборке Dynamo 1.x и DynamoRevit 1.x. Новые версии репозитория DynamoRevit используют диспетчер пакетов NuGet для загрузки необходимых зависимостей Dynamo. Хотя для сборки DynamoRevit 2.x не нужно извлекать Dynamo вручную, для запуска DynamoRevit addin потребуются файлы Core dlls, так что мы рекомендуем все равно загрузить и собрать Dynamo. См. подробности ниже: Создание репозитория с помощью Visual Studio

Поиск репозитория DynamoRevit на Github

Код проекта DynamoRevit и исходный код основного Dynamo хранятся на Github в отдельных репозиториях. Этот репозиторий содержит исходные файлы для узлов Revit и надстройку Revit, с помощью которой выполняется загрузка Dynamo. Сборки DynamoRevit для различных версий Revit (например, 2016, 2017 или 2018) существуют в репозитории как ветви.

Исходный код DynamoRevit находится здесь: https://github.com/DynamoDS/DynamoRevit

1. Клонирование или скачивание репозитория.

2. Ветви DynamoRevit ссылаются на версии Revit.

Клонирование репозитория с помощью Git

Так же, как мы извлекали репозиторий Dynamo, мы используем команду git clone, чтобы клонировать DynamoRevit и указать ветвь, соответствующую версии Revit. Для начала откроем интерфейс командной строки и зададим в качестве текущего каталога папку, в которую будут скопированы файлы.

cd C:\Users\username\Documents\GitHub заменяет текущий каталог

Замените username именем пользователя.

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

git clone https://github.com/DynamoDS/DynamoRevit.git клонирует репозиторий с удаленного URL и по умолчанию переключается на главную ветвь.

После клонирования репозитория измените текущий каталог на папку репозитория и перейдите в ветвь, соответствующую установленной версии Revit. В данном примере используется Revit RC2.13.1_Revit2023. Все удаленные ветви можно просмотреть на странице Github в раскрывающемся меню ветви.

cd C:\Users\username\Documents\GitHub\DynamoRevit меняет каталог на DynamoRevit. git checkout RC2.13.1_Revit2023 определяет в качестве текущей ветвь RC2.13.1_Revit2023. git branch проверяет, на какой ветви мы находимся, и отображает другие локальные ветви.

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

Важно выбрать правильную ветвь репозитория, чтобы при сборке проекта в Visual Studio он ссылался на сборки верной версии каталога установки Revit, а именно RevitAPI.dll и RevitAPIUI.dll.

Создание репозитория с помощью Visual Studio

Перед созданием репозитория необходимо восстановить пакеты NuGet с файлом restorepackages.bat в папке src. В этом BAT-файле используется диспетчер пакетов nuget для извлечения встроенных двоичных файлов Dynamo Core, необходимых для работы DynamoRevit. Их также можно создать вручную, но только если изменения вносятся в DynamoRevit, а не в ядро Dynamo. Это позволяет быстрее начать работу. Убедитесь, что этот файл запущен от имени администратора.

1. Щелкните правой кнопкой мыши restorepackages.bat и выберите Run as administrator (запуск от имени администратора).

Если пакеты успешно восстановлены, в папку packages будет добавлена папка src с последними бета-версиями пакетов NuGet.

1. Последние бета-версии пакетов Dynamo NuGet

После восстановления пакетов откройте файл решения DynamoRevit.All.sln Visual Studio в src и выполните сборку. В сборке могут изначально возникнуть проблемы с поиском AssemblySharedInfo.cs. Перезапустите сборку, чтобы устранить эту проблему.

1. Выберите Build > Build Solution (Сборка > Собрать решение).

2. В окне вывода вы должны увидеть сообщение об успешной сборке. Например: ===== Build: 13 succeeded, 0 failed, 0 up-to-date, 0 skipped =====.

Запуск локальной сборки DynamoRevit в Revit

Для распознавания DynamoRevit в Revit требуется файл надстройки, который автоматически создается программой установки. В процессе разработки нам необходимо вручную создать файл надстройки, указывающий на необходимую нам сборку DynamoRevit — DynamoRevitDS.dll. Кроме того, DynamoRevit необходимо связать со сборкой Dynamo.

Создайте файл Dynamo.addin в папке надстройки Revit, расположенной в папке C:\ProgramData\Autodesk\Revit\Addins\2023. У нас уже установлена версия DynamoRevit, поэтому мы просто отредактируем существующий файл, чтобы указать на новую сборку.

<?xml version="1.0" encoding="utf-8" standalone="no"?>
<RevitAddIns>
<AddIn Type="Application">
<Name>Dynamo For Revit</Name>
<Assembly>"C:\Users\username\Documents\GitHub\DynamoRevit\bin\AnyCPU\Debug\Revit\DynamoRevitDS.dll"</Assembly>
<AddInId>8D83C886-B739-4ACD-A9DB-1BC78F315B2B</AddInId>
<FullClassName>Dynamo.Applications.DynamoRevitApp</FullClassName>
<VendorId>ADSK</VendorId>
<VendorDescription>Dynamo</VendorDescription>
</AddIn>
</RevitAddIns>

• Укажите путь к файлу DynamoRevitDS.dll внутри <Assembly>...</Assembly>.

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

<?xml version="1.0" encoding="utf-8" standalone="no"?>
<RevitAddIns>
<AddIn Type="Application">
<Name>Dynamo For Revit</Name>
<Assembly>"C:\Users\username\Documents\GitHub\DynamoRevit\bin\AnyCPU\Debug\Revit\DynamoRevitVersionSelector.dll"</Assembly>
<AddInId>8D83C886-B739-4ACD-A9DB-1BC78F315B2B</AddInId>
<FullClassName>Dynamo.Applications.VersionLoader</FullClassName>
<VendorId>ADSK</VendorId>
<VendorDescription>Dynamo</VendorDescription>
</AddIn>
</RevitAddIns>

• Задайте путь к файлу <Assembly>...</Assembly>: DynamoRevitVersionSelector.dll

• <FullClassName>...</FullClassName> определяет, какой класс будет создан из сборки. Мы указали его в пути к элементу сборки выше. Этот класс будет отправной точкой для нашей надстройки.

Кроме того, необходимо удалить существующее приложение Dynamo, входящее в комплект поставки Revit. Для этого перейдите в раздел C:\\Program Files\Autodesk\Revit 2023\AddIns и удалите две папки, содержащие Dynamo: DynamoForRevit и DynamoPlayerForRevit. Их можно удалить или создать резервную копию в отдельной папке, если требуется восстановить исходное приложение Dynamo for Revit.

После этого необходимо добавить путь к файлу основных сборок Dynamo Dynamo.config в папку DynamoRevit bin. DynamoRevit загрузит их при открытии надстройки в Revit. Этот файл конфигурации позволяет указать надстройку DynamoRevit для различных версий Dynamo Core, чтобы разрабатывать и тестировать изменения в Core и DynamoRevit.

Код должен выглядеть так:

<?xml version="1.0" encoding="utf-8"?>
<configuration>
  <appSettings>
     <add key="DynamoRuntime" value="C:\Users\username\Documents\GitHub\Dynamo\bin\AnyCPU\Debug"/>
  </appSettings>
</configuration>

• Добавьте путь к <add key/> в папке bin.

Перед созданием руководства мы клонировали Dynamo и произвели сборку, чтобы гарантировать корректную работу DynamoRevit. Путь к папке указывает на эту сборку.

Теперь при открытии Revit на вкладке «Управление» должна появиться надстройка Dynamo.

1. Выберите Manage (Управление).

2. Щелкните значок надстройки Dynamo.

3. Экземпляр DynamoRevit.

Если отображается диалоговое окно с сообщением об ошибке, в котором показаны отсутствующие сборки, то, вероятно, обнаружено несоответствие между версиями Dynamo Core, созданными на основе этих сборок, и версиями, загружаемыми во время выполнения. Например, DynamoRevit с последними бета-версиями 2.0 пакетов Dynamo Core не будет работать при попытке запуска с помощью DLL-файлов Dynamo 1.3. Убедитесь, что версии репозиториев совпадают, а DynamoRevit извлекает корректную версию зависимостей nuget. Зависимости определены в файле package.json репозитория DynamoRevit.

Отладка DynamoRevit с помощью Visual Studio

В предыдущем разделе, Сборка Dynamo на основе исходного кода, мы кратко описали отладку в Visual Studio и способ присоединения Visual Studio к процессу. На примере исключения в узле Wall.ByCurveAndHeight рассмотрим процедуру присоединения к процессу, задания точек прерывания, пошагового выполнения кода и использования стека вызовов для определения источника исключения. Эти средства отладки обычно применяются к рабочим процессам разработки .Net и описаны за рамками данного руководства.

• Присоединение к процессу связывает выполняющееся приложение с Visual Studio для отладки. Если требуется отладить поведение в сборке DynamoRevit, можно открыть исходные файлы DynamoRevit в Visual Studio и присоединить процесс Revit.exe, который является родительским процессом надстройки DynamoRevit. Visual Studio использует файл обозначений (.pbd) для создания связи между выполняемыми сборками DynamoRevit и исходным кодом.

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

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

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

  В материалах 2000 вещей, которые необходимо знать о C# содержится более подробное описание стеков вызовов

Узел Wall.ByCurveAndHeight создает исключение, если в качестве входного значения кривой для него задана кривая PolyCurve с сообщением To BSPlineCurve Not Implemented. С помощью отладки мы можем выяснить точную причину, по которой узел не принимает выбранный тип геометрии в качестве входных данных параметра кривой. В следующем примере предполагается, что DynamoRevit успешно собран и может быть запущен как надстройка для Revit.

1. Узел Wall.ByCurveAndHeight вызвал исключение

Для начала откройте файл решения DynamoRevit.All.sln, запустите Revit, а затем надстройку DynamoRevit. Затем присоедините Visual Studio к процессу Revit с помощью окна Attach to Process (Присоединить к процессу).

Чтобы показать доступные процессы, необходимо запустить Revit и DynamoRevit

1. Откройте окно Attach to Process (Присоединить к процессу), выбрав Debug > Attach to Process... (Отладка > Присоединить к процессу).

2. Установите для параметра Transport (Транспорт) значение Default (По умолчанию).

3. Выберите Revit.exe.

4. Выберите Attach (Присоединить).

Присоединив Visual Studio к Revit, откройте исходный код Wall.ByCurveAndHeight в Wall.cs. Его можно найти в обозревателе решений в разделе Libraries > RevitNodes > Elements (Библиотеки > RevitNodes > Элементы) в области Public static constructors файла. Задайте точку прерывания в конструкторе типа стены, чтобы при выполнении узла в Dynamo процесс прерывался, и мы могли просмотреть каждую строку кода по отдельности. Обычно автоматические конструкторы Dynamo начинаются с By<parameters>.

1. Файл класса с конструктором для Wall.ByCurveAndHeight.

2. Чтобы задать точку прерывания, левой кнопкой мыши щелкните номер строки или правой кнопкой мыши щелкните строку кода, выберитеBreakpoint > Insert Breakpoint (Точка прерывания > Вставить точку прерывания).

После установки точки прерывания необходимо запустить процесс через функцию Wall.ByCurveAndHeight. Эту функцию можно повторно выполнить в Dynamo, заново подключив провод к одному из портов, что приведет к повторному выполнению узла. Точка прерывания будет достигнута в Visual Studio.

1. По достижении точки прерывания ее значок меняется.

2. В окне стека вызовов отображается следующий метод.

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

1. Инструменты отладки для навигации по коду.

2. Нажмите Step Over (Шаг с обходом), чтобы запустить выделенный код, а затем приостановить выполнение после возврата функции

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

Если продолжить пошаговое выполнение функции, возникнет исключение, отображаемое в окне DynamoRevit. В окне стека вызовов можно увидеть, что исключение изначально было создано методом Autodesk.Revit.CurveAPIUtils.CreateNurbsCurve. К счастью, здесь происходит обработка исключения, поэтому не происходит сбоя Dynamo. В процессе отладки мы выяснили контекст для проблемы, обнаружив в исходном коде другой метод.

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

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

2. Оператор, вызвавший исключение в ProtoToRevitCurve.cs.

3. В стеке вызовов видно, что исключение возникает не в пользовательском коде.

4. Всплывающее окно с информацией об исключении.

Этот процесс можно применить к любым исходным файлам, с которыми мы работаем. При разработке библиотеки узлов Zero-Touch для Dynamo Studio можно открыть исходный код библиотеки и подключить процесс Dynamo для отладки библиотеки узлов. Даже если все работает нормально, отладка послужит отличным способом изучения кода для понимания рабочих процессов.

Извлечение последней сборки

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

cd C:\Users\username\Documents\GitHub\DynamoRevit задает текущий каталог в репозитории DynamoRevit. git branch проверяет правильности ветви, RC2.13.1_Revit2023. git pull origin RC2.13.1_Revit2023 извлекает изменения из удаленной исходной ветви RC2.13.1_Revit2023.

Начало координат указывает на исходный URL-адрес, который мы клонировали.

Необходимо помнить о том, на какой ветви мы находимся и из какой ветви мы извлекаем изменения, чтобы не переносить ненужные изменения, скажем, из RC2.13.1_Revit2023 в Revit2018.

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

Выполнение сценариев Python в узлах Zero-Touch (C#)

Если вы умеете писать сценарии на языке Python и хотите получить расширенные возможности при использовании стандартных узлов Dynamo Python, создайте собственный узел с помощью технологии Zero-Touch. Начнем с простого примера, в котором мы передадим сценарий Python в виде строки в узел Zero-Touch, где сценарий выполнится и вернет результат. В этом практическом примере мы опираемся на пошаговые инструкции и примеры из раздела «Начало работы». Если вы еще не работали с узлами Zero-Touch, начните с этого раздела.

Узел Zero-Touch, выполняющий строку сценария Python

Обработчик Python

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

• Создайте новый проект класса Visual Studio.

• Добавьте ссылку на файл IronPython.dll, расположенный в папке C:\Program Files (x86)\IronPython 2.7\IronPython.dll.

• Добавьте ссылку на файл Microsoft.Scripting.dll, расположенный в папке C:\Program Files (x86)\IronPython 2.7\Platforms\Net40\Microsoft.Scripting.dll.

• Включите в класс операторы IronPython.Hosting и Microsoft.Scripting.Hosting using.

• Добавьте частный пустой конструктор, чтобы предотвратить добавление дополнительного узла в библиотеку Dynamo с пакетом.

• Создайте новый метод, при котором в качестве входного параметра используется одна строка.

• В рамках этого метода создается экземпляр нового обработчика Python и пустая область сценария. Вы можете представить эту область как глобальные переменные в экземпляре интерпретатора Python.

• Затем вызовите Execute в обработчике, передав входную строку и область в качестве параметров.

• Наконец, извлеките и верните результаты сценария. Для этого вызовите GetVariable в области и передайте имя переменной из сценария Python, содержащего возвращаемое значение. (См. пример ниже.)

Следующий код представляет пример для описанного выше шага. При сборке решения будет создан новый файл .dll, расположенный в папке bin нашего проекта. Теперь .dll можно импортировать в Dynamo в составе пакета или выбрав File < Import Library... (Файл > Импортировать библиотеку).

Несколько выходных данных

Одно из ограничений стандартных узлов Python заключается в том, что они имеют только один порт вывода, поэтому, если мы хотим вернуть несколько объектов, мы должны создать список и извлечь каждый объект. Если мы изменим приведенный выше пример для возврата словаря, мы можем добавить любое количество портов вывода. Более подробные сведения о словарях см. в разделе «Возврат нескольких значений» документа «Дальнейшая работа с Zero-Touch».

Этот узел позволяет возвращать как объем кубоида, так и его центр тяжести.

Изменим предыдущий пример, выполнив следующие действия:

• Добавьте ссылку на DynamoServices.dll из диспетчера пакетов NuGet.

• В дополнение к предыдущим сборкам включите System.Collections.Generic и Autodesk.DesignScript.Runtime.

• Измените тип возвращаемого значения метода, чтобы он возвращал словарь с выходными данными.

• Все выходные данные должны извлекаться из области по отдельности (рекомендуется создать простой цикл для больших наборов выходных данных)

В пример сценария Python мы добавили дополнительную выходную переменную (output2). Следует иметь в виду, что для таких переменных можно использовать любые соглашения об именовании Python. В данном примере название «output» используется только для наглядности.

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

Три среды разработки: Visual Studio, редактор Python и Code Block DesignScript

Какие варианты доступны?

Варианты разработки делятся на две главные категории: для Dynamo и в Dynamo. Разработка в Dynamo подразумевает создание содержимого с помощью Dynamo IDE для использования в Dynamo, а при разработке для Dynamo требуются внешние инструменты создания содержимого, которое затем будет импортировано в Dynamo. В этом руководстве рассматривается разработка для Dynamo, однако ниже приведены ссылки на материалы по всем доступным процессам.

Для Dynamo

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

• Узлы Zero-Touch

• Узлы, производные от NodeModel

• Расширения

В описании ниже Visual Studio используется в качестве среды разработки для узлов Zero-Touch и NodeModel.

Интерфейс Visual Studio с проектом, который мы будем разрабатывать

В Dynamo

• Блоки кода предоставляют DesignScript в среде визуального программирования, что позволяет использовать гибкие текстовые сценарии и рабочие процессы узла. Функция в блоке кода может быть вызвана любым объектом в рабочем пространстве.

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

• Узлы Python представляют собой интерфейс сценариев в среде визуального программирования, аналогичный блокам кода. В библиотеках Autodesk.DesignScript используется точечная нотация, аналогичная DesignScript.

При разработке в рабочем пространстве Dynamo мы сразу получаем обратную связь.

Разработка в рабочем пространстве Dynamo с помощью узла Python

Преимущества и недостатки каждого подхода

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

Блоки кода, узел Python и пользовательские узлы в Dynamo

Это простые варианты для написания кода в среде визуального программирования Dynamo. Рабочее пространство визуального программирования Dynamo обеспечивает доступ к Python, DesignScript и возможность включать в пользовательский узел несколько узлов.

С помощью этих методов мы можем:

• приступить к написанию кода Python или DesignScript почти без подготовки.

• импортировать библиотеки Python в Dynamo.

• делиться блоками кода, узлами Python и пользовательскими узлами с сообществом Dynamo в составе пакета.

Узлы Zero-Touch

Zero-Touch — это метод, позволяющий легко и быстро импортировать библиотеки C# одним щелчком мыши. Приложение Dynamo считывает общие методы из файла .dll и преобразует их в узлы Dynamo. Zero-Touch можно использовать для разработки собственных пользовательских узлов и пакетов.

С помощью этого метода можно:

• писать методы на языке C# и использовать их в качестве узлов в Dynamo.

• предоставлять сообществу Dynamo доступ к библиотеке C# в виде узлов в пакете.

Узлы, производные от NodeModel

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

С помощью этого метода можно:

• создать полностью настраиваемый пользовательский интерфейс узла с помощью ползунков, изображений, цвета и т. д. (например, узел ColorRange)

• получить доступ к инструментам в рабочей области Dynamo и управлять ими

• настроить переплетение.

• загрузить узел в Dynamo в виде пакета.

Управление версиями Dynamo и изменения API (1.x → 2.x)

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

Разрешение на распространение двоичных файлов в пакете

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

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

Понимая, как создать проект Zero-Touch, мы можем подробно рассмотреть особенности создания узла, изучив пример ZeroTouchEssentials на Dynamo Github.

Многие стандартные узлы Dynamo, по сути, являются узлами Zero-Touch, как и большинство узлов Math, Color и DateTime.

Для начала скачайте проект ZeroTouchEssentials на странице https://github.com/DynamoDS/ZeroTouchEssentials

В Visual Studio откройте файл решения ZeroTouchEssentials.sln и выполните сборку.

Файл ZeroTouchEssentials.cs содержит все методы, которые будут импортированы в Dynamo.

Откройте Dynamo и импортируйте ZeroTouchEssentials.dll, чтобы получить узлы, на которые мы будем ссылаться в следующих примерах.

Примеры кода извлекаются из ZeroTouchEssentials.cs. XML-документация удалена для краткости. В каждом примере с помощью кода будет создан узел, приведенный на изображении над ним.

Входные значения по умолчанию

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

• Задайте для параметров метода значение по умолчанию: inputNumber = 2.0

namespace ZeroTouchEssentials
{
    public class ZeroTouchEssentials
    {
        // Set the method parameter to a default value
        public static double MultiplyByTwo(double inputNumber = 2.0) 
        {
            return inputNumber * 2.0;
        }
    }
}

1. Значение по умолчанию отображается при наведении курсора на входной порт узла.

Возврат нескольких значений

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

• Добавьте using System.Collections.Generic; для использования Dictionary<>.

• Добавьте using Autodesk.DesignScript.Runtime; для использования атрибута MultiReturn. В данном случае ссылка на DynamoServices.dll содержится в пакете NuGet DynamoServices.

• Добавьте к методу атрибут [MultiReturn(new[] { "string1", "string2", ... more strings here })]. Строки ссылаются на ключи в словаре и становятся именами выходных портов.

• Выполните возврат Dictionary<> из функции с ключами, совпадающими с именами параметров в атрибуте: return new Dictionary<string, object>.

using System.Collections.Generic;
using Autodesk.DesignScript.Runtime;

namespace ZeroTouchEssentials
{
    public class ZeroTouchEssentials
    {
        [MultiReturn(new[] { "add", "mult" })]
        public static Dictionary<string, object> ReturnMultiExample(double a, double b)
        {
            return new Dictionary<string, object>

                { "add", (a + b) },
                { "mult", (a * b) }
            };
        }
    }
}

См. этот пример кода в ZeroTouchEssentials.cs

Узел, возвращающий несколько выходных данных.

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

Документация, подсказки и поиск

Рекомендуется прикреплять к узлам Dynamo документацию, описывающую функции узла, входные и выходные данные, теги поиска и т. д. Для этого используются теги XML-документации. XML-документация создается следующим образом.

• Документацией считается любой текст комментария после значка «///» (три наклонные черты),

  • Например: /// Documentation text and XML goes here (Текст документации и XML размещается здесь)

• После трех наклонных черт создайте теги XML над методами, которые Dynamo будет считывать при импорте DLL-файла.

  • Например: /// <summary>...</summary>

• Включите XML-документацию в Visual Studio, выбрав Project > Project Properties > Build (Проект > Свойства проекта > Сборка) и поставив флажок XML documentation file (Файл XML-документации).

1. Visual Studio создаст XML-файл в указанной папке.

Типы тегов:

• /// <summary>...</summary> обозначает основную документацию для узла, которая отображается в виде подсказки над узлом в строке поиска слева.

• /// <param name="inputName">...</param> создает документацию для конкретных входных параметров.

• /// <returns>...</returns> создает документацию для выходного параметра.

• /// <returns name = "outputName">...</returns> создает документацию для нескольких выходных параметров.

• /// <search>...</search> сопоставляет узел с результатами поиска на основе списка, разделенного запятыми. Например, если создать узел, который разделяет сетку, можно добавить такие теги, как mesh, subdivision и catmull-clark.

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

using Autodesk.DesignScript.Geometry;

namespace ZeroTouchEssentials
{
    public class ZeroTouchEssentials
    {
        /// <summary>
        /// This method demonstrates how to use a native geometry object from Dynamo
        /// in a custom method
        /// </summary>
        /// <param name="curve">Input Curve. This can be of any type deriving from Curve, such as NurbsCurve, Arc, Circle, etc</param>
        /// <returns>The twice the length of the Curve </returns>
        /// <search>example,curve</search>
        public static double DoubleLength(Curve curve)
        {
            return curve.Length * 2.0;
        }
    }
}

См. пример кода в ZeroTouchEssentials.cs

Обратите внимание на содержимое этого примера узла.

1. Сводка узла.

2. Описание входных данных.

3. Описание выходных данных.

Объекты

В Dynamo отсутствует ключевое слово new, поэтому объекты создаются с использованием статических методов конструирования. Объекты создаются следующим образом.

• Сделайте конструктор внутренним internal ZeroTouchEssentials(), если не требуется иное.

• Постройте объект с помощью статического метода, например public static ZeroTouchEssentials ByTwoDoubles(a, b).

Примечание. В Dynamo используется префикс «By», указывающий на то, что статический метод является конструктором. Использовать этот префикс необязательно, но с ним ваша библиотека будет соответствовать общепринятому стилю Dynamo.

namespace ZeroTouchEssentials
{
    public class ZeroTouchEssentials
    {
        private double _a;
        private double _b;

        // Make the constructor internal
        internal ZeroTouchEssentials(double a, double b)
        {
            _a = a;
            _b = b;
        }

        // The static method that Dynamo will convert into a Create node
        public static ZeroTouchEssentials ByTwoDoubles(double a, double b)
        {
            return new ZeroTouchEssentials(a, b);
        }
    }
}

См. пример кода в ZeroTouchEssentials.cs

После импорта DLL-файла ZeroTouchEssentials в библиотеке появится узел ZeroTouchEssentials. Этот объект можно создать с помощью узла ByTwoDoubles.

Использование типов геометрии Dynamo

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

• Вставьте ссылку на файл ProtoGeometry.dll в проект, добавив using Autodesk.DesignScript.Geometry; в верхней части файла C# и добавив пакет NuGet библиотеки ZeroTouchLibrary в проект.

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

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

using Autodesk.DesignScript.Geometry;

namespace ZeroTouchEssentials
{
    public class ZeroTouchEssentials
    {
        // "Autodesk.DesignScript.Geometry.Curve" is specifying the type of geometry input, 
        // just as you would specify a double, string, or integer 
        public static double DoubleLength(Autodesk.DesignScript.Geometry.Curve curve)
        {
            return curve.Length * 2.0;
        }
    }
}

См. пример кода в ZeroTouchEssentials.cs

Узел, который получает длину кривой и удваивает ее.

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

Удаление/использование операторов

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

• С помощью оператора using:

  Copy

  using (Point p1 = Point.ByCoordinates(0, 0, 0))
  {
    using (Point p2 = Point.ByCoordinates(10, 10, 0))
    {
        return Line.ByStartPointEndPoint(p1, p2);
    }
  }

  Документация об использовании оператора using

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

• При выполнении вызовов Dispose вручную:

  Copy

  Point p1 = Point.ByCoordinates(0, 0, 0);
  Point p2 = Point.ByCoordinates(10, 10, 0);
  Line l = Line.ByStartPointEndPoint(p1, p2);
  p1.Dispose();
  p2.Dispose();
  return l;

Миграция

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

• Создайте файл .xml в той же папке, что и файл .dll, в следующем формате: ИмяФайлаDLL.Migrations.xml.

• В диалоговом окне .xml создайте один элемент <migrations>...</migrations>.

• Внутри элемента миграции создайте элементы <priorNameHint>...</priorNameHint> для каждого изменения имени.

• При каждом изменении имени укажите <oldName>...</oldName> и <newName>...</newName>

1. Щелкните правой кнопкой мыши и выберите Add > New Item (Добавить > Новый элемент).

2. Выберите XML File (XML-файл).

3. В нашем проекте мы присвоим файлу миграции имя ZeroTouchEssentials.Migrations.xml.

Этот код указывает Dynamo, что узлы с именем GetClosestPoint теперь называются ClosestPointTo.

<?xml version="1.0"?>
<migrations>
  <priorNameHint>
    <oldName>Autodesk.DesignScript.Geometry.Geometry.GetClosestPoint</oldName>
    <newName>Autodesk.DesignScript.Geometry.Geometry.ClosestPointTo</newName>
  </priorNameHint>
</migrations>

См. пример кода в файле ProtoGeometry.Migrations.xml

Универсальные типы

Zero-Touch в настоящее время не поддерживает использование универсальных типов. Их можно использовать, но не в коде, который импортируется напрямую, если тип не задан. Универсальные методы, свойства и классы, у которых нет типа, нельзя предоставить.

В примере ниже узел Zero-Touch типа T не будет импортирован. Если остальные компоненты библиотеки импортируются в Dynamo, возникнут исключения отсутствующих типов.

public class SomeGenericClass<T>
{
    public SomeGenericClass()
    {
        Console.WriteLine(typeof(T).ToString());
    }  
}

При использовании универсального типа с типом, заданным в этом примере, импорт в Dynamo будет выполнен.

public class SomeWrapper
{
    public object wrapped;
    public SomeWrapper(SomeGenericClass<double> someConstrainedType)
    {
        Console.WriteLine(this.wrapped.GetType().ToString());
    }
}

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

Поиск репозиториев Dynamo на GitHub

GitHub — это хостинговая служба на базе Git, системы управления версиями, которая позволяет отслеживать изменения и координировать работу пользователей. Git можно использовать для скачивания исходных файлов Dynamo и их обновления с помощью нескольких команд. Этот метод позволяет избежать ненужной и изначально сложной работы по скачиванию и замене исходных файлов при каждом обновлении вручную. Система управления версиями Git отслеживает любые различия между локальным и удаленным репозиториями кода.

Исходный код Dynamo размещен в репозитории DynamoDS на GitHub: https://github.com/DynamoDS/Dynamo

Исходные файлы Dynamo.

1. Клонирование или скачивание всего репозитория

2. Другие репозитории DynamoDS

3. Исходные файлы Dynamo

4. Файлы, относящиеся к Git

Извлечение репозитория Dynamo с помощью Git

Установите Git, прежде чем клонировать репозиторий. Это краткое руководство содержит инструкции по установке и настройке адреса электронной почты и имени пользователя на GitHub. В нашем примере мы будем использовать Git в командной строке. В этом руководстве предполагается, что вы работаете в Windows, но вы также можете использовать Git для клонирования исходных файлов Dynamo в macOC или Linux.

Нам нужен URL-адрес для клонирования репозитория Dynamo. Его можно найти, нажав кнопку «Clone or download» (Клонировать или скачать) на странице репозитория. Скопируйте URL-адрес для вставки в командную строку.

1. Нажмите «Clone or download» (Клонировать или скачать).

2. Скопируйте URL.

После установки Git можно клонировать хранилище Dynamo. Для начала откройте командную строку. Затем с помощью команды смены каталога cd перейдите к папке, в которую необходимо клонировать исходные файлы. В нашем примере мы создали папку с именем Github в папке Documents.

cd C:\Users\username\Documents\GitHub

Замените username на ваше имя пользователя

На следующем этапе мы выполним команду Git, чтобы клонировать хранилище Dynamo в указанную папку. URL в команде можно получить, нажав кнопку Clone or download (Клонировать или скачать) на GitHub. Выполните эту команду в командной строке терминала. Обратите внимание, что эта операция приведет к клонированию главной ветви репозитория Dynamo, где хранится последняя версия кода Dynamo. Эта ветвь меняется ежедневно.

git clone https://github.com/DynamoDS/Dynamo.git

Если операция клонирования успешно завершена, Git будет работать. В проводнике перейдите в папку, в которую были скопированы исходные файлы. Структура папок должна выглядеть так же, как в главной ветви репозитория Dynamo на Github.

1. Исходные файлы Dynamo

2. Файлы Git

Создание репозитория с помощью Visual Studio

Мы клонировали исходные файлы на локальный компьютер и теперь можем собрать исполняемый файл для Dynamo. Для этого потребуется настроить среду разработки Visual Studio IDE и убедиться, что .NET Framework и DirectX установлены.

• Скачайте и установите Microsoft Visual Studio Community 2015 (или более поздних версий) — бесплатную полнофункциональную IDE (интегрированную среду разработки).

• Скачайте и установите Microsoft .NET Framework 4.5 или более поздней версии.

• Установите Microsoft DirectX из локального репозитория Dynamo (Dynamo\tools\install\Extra\DirectX\DXSETUP.exe).

Возможно, .NET и DirectX уже установлены.

После завершения установки запустим Visual Studio и откроем файл Dynamo.All.sln, который находится в папке Dynamo\src.

1. Выберите File > Open > Project/Solution (Файл > Открыть > Проект/решение).

2. Перейдите в репозиторий Dynamo и откройте папку src.

3. Выберите файл решения Dynamo.All.sln.

4. Нажмите Open (Открыть).

Прежде чем собрать решение, необходимо указать несколько параметров. Сначала необходимо создать отладочную версию Dynamo — так Visual Studio сможет собирать больше информации во время отладки, чтобы помочь нам в разработке. В качестве целевой платформы выберите AnyCPU (любой ЦП).

Они будут преобразованы в папки в каталоге bin

1. В данном примере выбрано Debug (Отладка) в качестве конфигурации решения.

2. Задайте для платформы решения значение Any CPU.

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

При сборке проекта будут восстановлены зависимости NuGet.

1. Выберите Build > Build Solution (Сборка > Собрать решение).

2. В окне вывода отобразится сообщение об успешной сборке. Например: ==== Build: 69 succeeded, 0 failed, 0 up-to-date, 0 skipped ====.

Выполнение локальной сборки

Если сборка Dynamo выполнена успешно, в репозитории Dynamo будет создана папка bin с файлом DynamoSandbox.exe. Мы выполняем сборку с параметром Debug, поэтому исполняемый файл находится в папке bin\AnyCPU\Debug. При запуске откроется локальная сборка Dynamo.

1. Только что созданный исполняемый файл DynamoSandbox. Выполните его, чтобы запустить Dynamo.

На этом этапе все почти готово для разработки для Dynamo.

Инструкции по сборке Dynamo для других платформ (например, Linux или OS X) см. на вики-странице.

Отладка локальной сборки с помощью Visual Studio

Отладка представляет собой процесс выявления, изоляции и исправления ошибок или проблем. После успешной сборки Dynamo на основе исходного кода можно использовать несколько инструментов Visual Studio для отладки выполняющегося приложения. Например, надстройку DynamoRevit. Мы можем проанализировать исходный код, чтобы найти причину проблемы, или просмотреть выполняемый в данный момент код. Более подробное описание процедуры отладки кода и навигации по нему в Visual Studio см. в документации по Visual Studio.

Для автономного приложения Dynamo, DynamoSandbox, мы рассмотрим два варианта отладки:

• Создание и запуск Dynamo непосредственно из Visual Studio.

• Присоединение Visual Studio к запущенному процессу Dynamo.

При запуске Dynamo из Visual Studio решение собирается заново для каждого сеанса отладки, если это необходимо. После редактирования исходного кода внесенные изменения будут учтены при отладке. Не закрывая решение Dynamo.All.sln, выберите Debug, AnyCPU и DynamoSandbox в раскрывающемся меню, а затем нажмите Start (Запуск). При этом будет выполнена сборка Dynamo, запущен новый процесс (DynamoSandbox.exe) и к нему присоединен отладчик Visual Studio.

Создание и запуск приложения непосредственно из Visual Studio

1. Выберите конфигурацию Debug (Отладка).

2. Выберите платформу Any CPU (Любой ЦП).

3. Выберите для проекта DynamoSandbox.

4. Нажмите Start (Запуск), чтобы начать процесс отладки.

Кроме того, можно выполнить отладку уже запущенного процесса Dynamo для устранения неполадки, связанной с открытым графиком или пакетом. Для этого необходимо открыть исходные файлы проекта в Visual Studio и присоединить их к выполняющемуся процессу Dynamo с помощью элемента меню отладки Attach to Process (Присоединить к процессу).

Присоединение выполняющегося процесса к Visual Studio

1. Выберите Debug > Attach to Process... (Отладка > Присоединить к процессу)

2. Выберите DynamoSandbox.exe.

3. Выберите Attach (Присоединить).

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

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

1. Точка прерывания

2. Стек вызовов, отображающий выполняемую в данный момент функцию и предыдущие вызовы функции.

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

Извлечение последней сборки

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

В командной строке выберите в качестве текущего каталога репозиторий Dynamo:

cd C:\Users\username\Documents\GitHub\Dynamo

Замените "username" на ваше имя пользователя

Используйте следующую команду для извлечения последних изменений:

git pull origin master

1. Здесь видно, что локальный репозиторий был обновлен с учетом изменений в удаленном репозитории.

Помимо извлечения обновлений нужно знать еще о четырех рабочих процессах Git.

• Создайте вилку репозитория Dynamo, чтобы получить копию, отдельную от оригинала. Внесенные здесь изменения не повлияют на исходный репозиторий, но мы можем извлекать обновления и отправлять запросы на слияние. Создание вилок — это один из самых популярных способов разработки проектов с открытым исходным кодом на GitHub. Если вы хотите предложить улучшения для Dynamo, ознакомьтесь с этим методом.

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

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

• Создавайте запросы на внесение изменений, чтобы предложить изменения для главного репозитория Dynamo.

Команда Dynamo предоставляет специальные инструкции по созданию запросов на слияние. Дополнительные сведения см. в разделе «Запросы на слияние» этого руководства.

Список команд Git см. на странице документации.

Для чего предназначено это руководство?

Это руководство поможет вам освоить различные возможности разработки на языке C# для Dynamo — от создания узлов Zero-Touch до сборки расширений.

Репозиторий Dynamo на GitHub

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

Dynamo: скачайте последние стабильные и ежедневные сборки Dynamo

https://dynamobuilds.com/

Репозиторий Dynamo на GitHub. Dynamo — это проект разработки с открытым исходным кодом, размещенный на GitHub.

https://github.com/DynamoDS/Dynamo

Вики-страница Dynamo на Github — это основной источник документации для разработчиков.

https://github.com/DynamoDS/Dynamo/wiki

Стандарты именования узлов — стандарты и рекомендации по именованию категорий, узлов, а также портов ввода и вывода в Dynamo.

https://github.com/DynamoDS/Dynamo/wiki/Naming-Standards

Руководство по языку и API Dynamo: в документации по API Dynamo в настоящее время рассматриваются основные функции

https://dynamods.github.io/DynamoAPI/

DynamoBIM. Веб-сайт DynamoBIM — это лучшее место для получения дополнительной информации, поиска обучающих материалов и общения на форумах.

https://dynamobim.org

Словарь Dynamo — база данных всех узлов Dynamo с возможностью поиска

https://dictionary.dynamobim.com/

Руководство по языку DesignScript — PDF-файл с руководством по написанию DesignScript

PDF

Как можно предложить изменения в этом руководстве?

Мы открыты для предложений. Создайте запрос на внесение изменений на Github, чтобы мы могли внести правки напрямую.

Мы подготовили проект Visual Studio, а теперь рассмотрим, как создать пользовательский узел, создающий прямоугольную сетку ячеек. Такую сетку можно создать с помощью нескольких стандартных узлов, однако мы также можем легко включить этот полезный инструмент в узел Zero-Touch. В отличие от линий сетки, ячейки можно масштабировать относительно центральных точек, запрашивать их угловые вершины или встраивать в грани.

В этом примере рассматриваются некоторые возможности и концепции, которые необходимо учитывать при создании узла Zero-Touch. После создания пользовательского узла и его добавления в Dynamo откройте страницу «Дальнейшая работа с Zero-Touch», чтобы просмотреть входные значения по умолчанию, возвращенные значения, документацию, объекты, типы геометрии Dynamo и миграцию.

Пользовательский узел прямоугольной сетки

Чтобы начать построение узла сетки, создайте новый проект библиотеки классов Visual Studio. Подробные инструкции по настройке проекта см. на странице «Начало работы».

1. Выберите Class Library (Библиотека классов) в качестве типа проекта.

2. Присвойте проекту имя CustomNodes.

Поскольку мы будем создавать геометрию, необходима ссылка на соответствующий пакет NuGet. Установите пакет ZeroTouchLibrary из диспетчера пакетов Nuget. Этот пакет необходим для оператора using Autodesk.DesignScript.Geometry;.

1. Найдите пакет ZeroTouchLibrary.

2. Этот узел будет использоваться в текущей сборке Dynamo Studio — 1.3. Выберите версию пакета, соответствующую этой сборке.

3. Обратите внимание, что мы переименовали файл класса в Grids.cs.

Далее необходимо установить пространство имен и класс, в котором будет использоваться метод RectangularGrid. В Dynamo узел будет назван в соответствии с методом и именами классов. Пока не нужно копировать его в Visual Studio.

using Autodesk.DesignScript.Geometry;
using System.Collections.Generic;

namespace CustomNodes
{
    public class Grids
    {
        public static List<Rectangle> RectangularGrid(int xCount, int yCount)
        {
        //The method for creating a rectangular grid will live in here
        }
    }
}

Autodesk.DesignScript.Geometry; ссылается на файл ProtoGeometry.dll в пакете ZeroTouchLibrary System.Collections.Generic, который необходим для создания списков.

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

using Autodesk.DesignScript.Geometry;
using System.Collections.Generic;

namespace CustomNodes
{
    public class Grids
    {
        public static List<Rectangle> RectangularGrid(int xCount, int yCount)
        {
            double x = 0;
            double y = 0;

            var pList = new List<Rectangle>();

            for (int i = 0; i < xCount; i++)
            {
                y++;
                x = 0;
                for (int j = 0; j < yCount; j++)
                {
                    x++;
                    Point pt = Point.ByCoordinates(x, y);
                    Vector vec = Vector.ZAxis();
                    Plane bP = Plane.ByOriginNormal(pt, vec);
                    Rectangle rect = Rectangle.ByWidthLength(bP, 1, 1);
                    pList.Add(rect);
                }
            }
            return pList;
        }
    }
}

Если ваш проект выглядит аналогично, выполните сборку .dll.

1. Выберите Build > Build Solution (Сборка > Собрать решение).

Проверьте папку проекта bin на наличие файла .dll. Если сборка прошла успешно, можно добавить .dll в Dynamo.

1. Пользовательский узел RectangularGrids в библиотеке Dynamo.

2. Пользовательский узел в рабочей области.

3. Кнопка Add (Добавить) для добавления файл .dll в Dynamo.

Пользовательские изменения узлов

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

1. Входное значение по умолчанию.

2. Подсказка для ввода xCount.

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

using Autodesk.DesignScript.Geometry;
using System.Collections.Generic;

namespace CustomNodes
{
    public class Grids
    {
        /// <summary>
        /// This method creates a rectangular grid from an X and Y count.
        /// </summary>
        /// <param name="xCount">Number of grid cells in the X direction</param>
        /// <param name="yCount">Number of grid cells in the Y direction</param>
        /// <returns>A list of rectangles</returns>
        /// <search>grid, rectangle</search>
        public static List<Rectangle> RectangularGrid(int xCount = 10, int yCount = 10)
        {
            double x = 0;
            double y = 0;

            var pList = new List<Rectangle>();

            for (int i = 0; i < xCount; i++)
            {
                y++;
                x = 0;
                for (int j = 0; j < yCount; j++)
                {
                    x++;
                    Point pt = Point.ByCoordinates(x, y);
                    Vector vec = Vector.ZAxis();
                    Plane bP = Plane.ByOriginNormal(pt, vec);
                    Rectangle rect = Rectangle.ByWidthLength(bP, 1, 1);
                    pList.Add(rect);
                    Point cPt = rect.Center();
                }
            }
            return pList;
        }
    }
}

• Задайте значения по умолчанию для входных данных, назначив параметрам метода RectangularGrid(int xCount = 10, int yCount = 10).

• Создавайте подсказки для входных и выходных данных, ключевые слова для поиска и описание с XML-документацией, используя /// в качестве префикса.

Для добавления подсказок нам потребуется файл XML в папке проекта. Visual Studio может автоматически создать файл .xml, если этот параметр выбран.

1. Прикрепите файл XML-документации и укажите путь к файлу. При этом создается файл XML.

Вот и все! Мы создали новый узел с несколькими стандартными элементами. В следующей главе, «Основы Zero-Touch», подробно рассматриваются вопросы разработки узлов Zero-Touch и возможные проблемы.

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

Создание проекта Visual Studio

Visual Studio — это многофункциональная среда разработки, в которой можно создавать проекты, добавлять ссылки, создавать файлы .dll и выполнять отладку. При создании нового проекта Visual Studio также создается решение, структура для организации проектов. В одном решении можно создать несколько проектов, которые будут собраны вместе. Чтобы создать узел ZeroTouch, необходимо запустить новый проект Visual Studio, в котором будет создана библиотека классов C# и собран файл .dll.

Окно New Project (Создать проект) в Visual Studio

1. Для начала откройте Visual Studio и создайте новый проект: File > New > Project (Файл > Создать > Проект).

2. Выберите шаблон проекта Class Library (Библиотека классов).

3. Присвойте проекту имя (мы назвали проект MyCustomNode).

4. Задайте путь к файлу проекта. В нашем примере мы оставим расположение по умолчанию

5. Нажмите Ok.

Visual Studio автоматически создаст и откроет файл C#. Мы должны присвоить ему соответствующее имя, настроить рабочее пространство и заменить код по умолчанию на этот метод умножения.

 namespace MyCustomNode
 {
     public class SampleFunctions
     {
         public static double MultiplyByTwo(double inputNumber)
         {
             return inputNumber * 2.0;
         }
     }
 }

1. Откройте обозреватель решений и окна вывода в меню View (Вид).

2. Переименуйте файл Class1.cs в SampleFunctions.cs в обозревателе решений справа.

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

4. Обозреватель решений предоставляет доступ ко всем компонентам проекта.

5. Окно вывода понадобится позже, чтобы проверить, успешно ли выполнена сборка.

Следующий шаг — собрать проект. Но сначала необходимо кое-что проверить. Убедитесь, что в качестве целевой платформы выбрано Any CPU или x64, а флажок Prefer 32-bit (Предпочтительно 32-разрядная) в свойствах проекта снят.

1. Откройте свойства проекта, выбрав Project > "ProjectName" Properties (Проект > Свойства имя_проекта).

2. Выберите страницу Build (Сборка).

3. Выберите Any CPU или x64 в раскрывающемся меню.

4. Убедитесь, что флажок Prefer 32-bit (Предпочтительно 32-разрядная) снят.

Теперь можно собрать проект, чтобы создать файл .dll. Для этого выберите Build Solution (Собрать решение) в меню Build (Сборка) или нажмите клавиши CTRL+SHIFT+B.

1. Выберите Build > Build Solution (Сборка > Собрать решение).

2. Чтобы определить, успешно ли собран проект, проверьте окно вывода.

Если проект собран успешно, в папке проекта bin появится файл .dll с именем MyCustomNode. В нашем примере мы оставили путь к файлу проекта, как указано в Visual Studio по умолчанию: c:\users\username\documents\visual studio 2015\Projects. Давайте рассмотрим структуру файлов проекта.

1. Папка bin содержит файл .dll, собранный в Visual Studio.

2. Файл проекта Visual Studio.

3. Файл класса.

4. Поскольку в конфигурации решения задано значение Debug (Отладка), .dll будет создан в bin\Debug.

Теперь можно открыть Dynamo и импортировать .dll. С помощью функции добавления перейдите к папке проекта bin и выберите файл .dll, который требуется открыть.

1. Нажмите кнопку Add (Добавить) для импорта .dll.

2. Перейдите к папке проекта. Наш проект находится в папке файла Visual Studio по умолчанию: C:\Users\username\Documents\Visual Studio 2015\Projects\MyCustomNode.

3. Выберите MyCustomNode.dll для импорта.

4. Нажмите Open (Открыть), чтобы загрузить .dll.

Если категория была создана в библиотеке с именем MyCustomNode, то DLL-файл импортирован успешно. Однако Dynamo создал два узла, а мы хотели, чтобы узел был один. В следующем разделе вы узнаете, почему так происходит и как Dynamo считывает DLL-файл.

1. MyCustomNode в библиотеке Dynamo. Категория «Библиотека» определяется именем .dll.

2. SampleFunctions.MultiplyByTwo в рабочей области.

Способы чтения классов и методов в Dynamo

Когда Dynamo загружает DLL-файл, он предоставляет все открытые статические методы в виде узлов. Конструкторы, методы и свойства преобразуются в узлы Create, Action и Query соответственно. В нашем примере умножения метод MultiplyByTwo() становится узлом Action в Dynamo. Это связано с тем, что узел назван в соответствии с методом и классом.

1. Входным данным присваивается имя inputNumber на основе имени параметра метода.

2. По умолчанию выходным данным присваивается имя double, так как это возвращаемый тип данных.

3. Узел называется SampleFunctions.MultiplyByTwo, так как содержит имена классов и методов.

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

namespace MyCustomNode
{
    public class SampleFunctions
    {
        //The empty private constructor.
        //This will be not imported into Dynamo.
        private SampleFunctions() { }

        //The public multiplication method. 
        //This will be imported into Dynamo.
        public static double MultiplyByTwo(double inputNumber)
        {
            return inputNumber * 2.0;
        }
    }
}

1. Dynamo импортировал метод в качестве узла Create.

Добавление ссылок на пакеты Dynamo NuGet

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

• ZeroTouchLibrary — пакет для создания библиотек автоматических узлов для Dynamo, который содержит следующие библиотеки: DynamoUnits.dll, ProtoGeometry.dll

• WpfUILibrary — пакет для сборки библиотек узлов Dynamo с пользовательским интерфейсом в WPF, который содержит следующие библиотеки: DynamoCoreWpf.dll, CoreNodeModels.dll, CoreNodeModelWpf.dll

• DynamoServices — библиотека DynamoServices для Dynamo

• Core — инфраструктура модульного и системного тестирования для Dynamo, которая содержит следующие библиотеки: DSIronPython.dll, DynamoApplications.dll, DynamoCore.dll, DynamoInstallDetective.dll, DynamoShapeManager.dll, DynamoUtilities.dll, ProtoCore.dll, VMDataBridge.dll

• Tests — инфраструктура модульного и системного тестирования для Dynamo, которая содержит следующие библиотеки: DynamoCoreTests.dll, SystemTestServices.dll, TestServices.dll

• DynamoCoreNodes — пакет для сборки базовых узлов Dynamo, содержащий следующие библиотеки: Analysis.dll, GeometryColor.dll, DSCoreNodes.dll

Чтобы ссылаться на эти пакеты в проекте Visual Studio, скачайте пакет из NuGet по ссылкам выше и вручную укажите ссылки на DLL-файлы или используйте диспетчер пакетов NuGet в Visual Studio. Сначала мы рассмотрим, как их установить с помощью NuGet в Visual Studio.

1. Откройте диспетчер пакетов NuGet, выбрав Tools > NuGet Package Manager > Manage NuGet Packages for Solution... (Инструменты > Диспетчер пакетов NuGet > Управлять пакетами NuGet для решения).

Это диспетчер пакетов NuGet. В этом окне мы видим установленные для проекта пакеты и можем искать другие пакеты. Если выпущена новая версия пакета DynamoServices, можно обновить пакеты в этом разделе или вернуться к более ранней версии.

1. Нажмите кнопку обзора и найдите DynamoVisualProgramming, чтобы открыть пакеты Dynamo.

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

3. Выберите нужную версию пакета и нажмите кнопку Install (Установить). Пакет будет установлен для проекта, в котором вы работаете. Так как используется последняя стабильная версия Dynamo 1.3, выберите соответствующую версию пакета.

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

1. Щелкните правой кнопкой мыши References (Ссылки) и выберите Add Reference (Добавить ссылку).

2. Нажмите Browse (Обзор), чтобы перейти к папке пакета.

Итак, мы настроили Visual Studio и добавили .dll в Dynamo. Теперь у нас есть надежная основа для дальнейшей работы. И это только начало. Далее вы узнаете, как создать пользовательский узел.

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

Сборка в папку пакета

Существует два способа сборки пакета в Visual Studio.

• Добавьте события после сборки в диалоговом окне «Параметры проекта», в котором для копирования необходимых файлов используются сценарии xcopy или Python.

• Используйте целевой объект сборки AfterBuild в файле .csproj для создания задач копирования файлов и каталогов.

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

Копирование файлов пакетов с помощью метода AfterBuild

Настройте структуру папок в репозитории так, чтобы исходные файлы были отделены от файлов пакетов. При работе с примером CustomNodeModel поместите проект Visual Studio и все связанные файлы в новую папку src. Все пакеты, созданные в проекте, будут сохранены в этой папке. Структура папок должна выглядеть следующим образом:

1. Переместите файлы проекта в новую папку src.

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

1. Поместите целевой объект AfterBuild перед закрывающим тегом </Project>.

В разделе <ItemGroup> задается ряд переменных, представляющих определенные типы файлов. Например, переменная Dll представляет все файлы в выходной папке с расширением .dll.

Задача Copy состоит в том, чтобы скопировать все файлы .dll в каталог, а именно в папку пакета, в которую мы выполняем сборку.

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

Теперь при построении проекта в папке проекта будет находится папка packages рядом с ранее созданной папкой src. В каталоге packages находится папка, содержащая все необходимые для пакета компоненты. Также необходимо скопировать файл pkg.json в папку пакета, чтобы сообщить Dynamo о необходимости загрузки пакета.

1. Новая папка пакетов, созданная целевым объектом AfterBuild.

2. Существующая папка src с проектом.

3. Папки dyf и extra, созданные из целевого объекта AfterBuild.

4. Скопируйте файл pkg.json вручную.

Теперь можно опубликовать пакет с помощью диспетчера пакетов Dynamo или скопировать его непосредственно в папку пакетов Dynamo: <user>\AppData\Roaming\Dynamo\1.3\packages.

Введение

Dynamo 2.0 — это основной выпуск, в котором изменены или удалены некоторые API. Одно из самых значительных изменений, которое повлияет на разработчиков узлов и пакетов, — это переход на формат JSON.

В целом, от разработчиков узлов Zero-Touch не требуется никаких дополнительных действий для запуска пакетов версии 2.0.

Узлы пользовательского интерфейса и узлы, производные от NodeModel, требуют доработки для совместимости с версией 2.x.

Разработчикам расширений также потребуется внести некоторые изменения в зависимости от того, в каком объеме они используют API Dynamo Core в своих расширениях.

Общие правила упаковки:

• Не объединяйте DLL-файлы Dynamo или Dynamo Revit с пакетом. Эти DLL-файлы будут загружены Dynamo. Если ваша версия отличается от той, которую загрузил пользователь, (то есть, вы распространяете Dynamo Core 1.3, а пользователь запускает пакет в Dynamo 2.0) во время выполнения возникнут непредвиденные ошибки. Это относится к таким библиотекам DLL, как DynamoCore.dll, DynamoServices.dll, DSCodeNodes.dll, ProtoGeometry.dll.

• Не объединяйте и не распространяйте newtonsoft.json.net вместе с пакетом, если это возможно. Этот DLL-файл также будет загружен в Dynamo 2.x. Может возникнуть та же проблема, что и выше.

• Не объединяйте и не распространяйте CEFSharp вместе с пакетом, если этого можно избежать. Этот DLL-файл также будет загружен в Dynamo 2.x. Может возникнуть та же проблема, что и выше.

• В целом, не допускайте совместного использования зависимостей Dynamo или Revit, если требуется управлять версией такой зависимости.

Распространенные проблемы:

1) При открытии графика у некоторых узлов несколько портов с одинаковым именем, но график выглядит нормально при сохранении. Эта проблема может происходить по нескольким причинам.

Обычно это связано с тем, что узел был создан с помощью конструктора, который воссоздал порты. Вместо него должен был использоваться конструктор, загружающий порты. Эти конструкторы обычно помечены как [JsonConstructor] см. примеры ниже.

Это может произойти по следующим причинам.

• Соответствующий [JsonConstructor] просто отсутствует, или Inports и Outports не переданы из JSON DYN.

• В один и тот же процесс одновременно загружены две версии JSON.net, что привело к сбою в среде выполнения .NET, поэтому атрибут [JsonConstructor] невозможно корректно использовать для обозначения конструктора.

• Файл DynamoServices.dll, версия которого отличается от текущей версии Dynamo, включен в пакет и вызывает ошибку определения атрибута [MultiReturn] в среде выполнения .NET, поэтому невозможно применить необходимые атрибуты к узлам Zero-Touch. Возможно, узел возвращает один выходной словарь вместо нескольких портов.

2) При загрузке графика полностью отсутствуют узлы, при этом в консоли возникают ошибки.

• Это может произойти, если по какой-либо причине не удалось выполнить десериализацию. Рекомендуется сериализовать только необходимые свойства. Можно использовать [JsonIgnore] со сложными свойствами, которые не нужно загружать или сохранять, чтобы игнорировать их. Это могут быть такие свойства, как function pointer, delegate, action, или event и т. д. Их не следует сериализовать, так как обычно их невозможно десериализовать, и они могут вызвать ошибку во время выполнения.

Подробное описание обновления:

Пользовательские узлы 1.3 - > 2.0

Известные проблемы

• Комментарии будут преобразованы в комментарии к блокам, а не к строкам.

• Короткие имена типов будут заменены полными именами. Например, если при повторной загрузке пользовательского узла тип не был указан, то отобразится var[]..[], так как это тип по умолчанию.

Узлы Zero Touch 1.3 -> 2.0

• Типы списка и словаря в Dynamo 2.0 разделены, а синтаксис создания списков и словарей изменен. Списки инициализируются с помощью [], а словари — {}. Если ранее для маркировки параметров на узлах Zero-Touch использовался атрибут DefaultArgument, а синтаксис списка использовался по умолчанию для определенного списка, например someFunc([DefaultArgument("{0,1,2}")]), то этот атрибут больше не будет действительным, и для использования нового синтаксиса инициализации списков потребуется изменить фрагмент кода DesignScript.

• Как указано выше, DLL-файлы Dynamo не распространяются вместе с пакетами (DynamoCore, DynamoServices и т. д.).

Узлы NodeModel 1.3 -> 2.0

Больше всего работы потребуется для обновления узлов NodeModel до версии Dynamo 2.x. В двух словах, необходимо будет реализовать конструкторы, которые будут использоваться только для загрузки узлов из JSON, в дополнение к обычным конструкторам nodeModel, используемым для создания новых экземпляров типов узлов. Чтобы различать их, нужно пометить конструкторы времени загрузки атрибутом [JsonConstructor] из newtonsoft.Json.net.

Конструкторы JSON

Чаще всего для обновления узлов, производных от базового класса NodeModel (или других базовых классов Dynamo Core, т. е. DSDropDownBase), требуется добавить конструктор JSON в класс.

Исходный конструктор без параметров будет по-прежнему обрабатывать инициализацию нового узла, созданного в Dynamo (например, с помощью библиотеки). Конструктор JSON необходим для инициализации десериализованного узла (загруженного) из сохраненного файла DYN или DYF.

Конструктор JSON отличается от базового конструктора тем, что имеет параметры PortModel для inPorts и outPorts, которые предоставляются логикой загрузки JSON. Вызов для регистрации портов для узла не требуется, поскольку данные существуют в файле DYN. Пример конструктора JSON:

using Newtonsoft.Json; //New dependency for Json (Новая зависимость для JSON)

………

[JsonConstructor] //Attribute required to identity the Json constructor (Атрибут, необходимый для идентификации конструктора JSON)

//Minimum constructor implementation. Note that the base method invocation must also be present. (Минимальная реализация конструктора. Обратите внимание, что также должен присутствовать вызов базового метода)

FooNode(IEnumerable<PortModel> inPorts, IEnumerable<PortModel> outPorts) : base(inPorts, outPorts) { }

Этот синтаксис :base(Inports,outPorts){} вызывает базовый конструктор nodeModel и передает ему десериализованные порты.

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

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

Общие свойства и сериализация

[JsonProperty(PropertyName = "InputValue")]

public DSColor DsColor {...

Конвертеры:

Примечание. Если вы создаете собственный класс конвертера JSON.NET, в Dynamo в настоящее время нет механизма для его вставки в методы загрузки и сохранения. Поэтому даже если класс помечен атрибутом [JsonConverter], он может не использоваться. Вместо этого можно вызвать конвертер непосредственно в установщике или получателе. //TODO: требуется подтверждение этого ограничения. Приветствуются любые подтверждения.

[JsonProperty("MeasurementType"), JsonConverter(typeof(StringEnumConverter))]

public ConversionMetricUnit SelectedMetricConversion{...

Игнорирование свойств

Отмена и повтор

Как уже упоминалось выше, методы SerializeCore и DeserializeCore ранее использовались для сохранения и загрузки узлов в файл XML DYN. Кроме того, они также использовались для сохранения и загрузки состояния узла для команд отмены и повтора, и по-прежнему применяются в этих целях. Если требуется реализовать сложную функцию отмены и повтора для узла пользовательского интерфейса nodeModel, необходимо реализовать эти методы и сериализовать их в объект XML-документа, предоставляемый в качестве параметра для этих методов. Применяйте этот способ, только если используете сложные узлы пользовательского интерфейса.

API портов ввода и вывода

Один из аспектов в узлах nodeModel, на которые повлияют изменения в API версии 2.0, — это регистрация портов в конструкторе узлов. Примеры в Dynamo или DynamoSamples можно найти в предыдущих версиях, где использовались методы InPortData.Add() и OutPortData.Add(). Ранее в API Dynamo открытые свойства InPortData и OutPortData были помечены как устаревшие. В версии 2.0 эти свойства удалены. Разработчикам теперь следует использовать методы InPorts.Add() и OutPorts.Add(). Кроме того, у этих двух методов Add() немного отличаются подписи:

InPortData.Add(new PortData("Port Name", "Port Description")); //Old version valid in 1.3 but now deprecated (Старая версия 1.3 действительна, но устарела)

vs

InPorts.Add(new PortModel(PortType.Input, this, new PortData("Port Name", "Port Description"))); //Recommended 2.0 (Рекомендуется 2.0)

Примеры:

Рассмотрим обновление узла пользовательского интерфейса версии 1.3 до версии Dynamo 2.x.

Все, что нам нужно сделать с этим классом nodeModel, чтобы он корректно загружался и сохранялся в версии 2.0, — это добавить jsonConstructor для обработки загрузки портов. Мы просто передаем порты в базовом конструкторе, и это пустая реализация.

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

Ниже приведен более сложный конструктор для узла пользовательского интерфейса:

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

Обратите внимание, что другие общие свойства, сериализованные в JSON, например ButtonText и WindowText, не будут добавлены в конструктор как явные параметры. Они устанавливаются автоматически в JSON.NET с помощью методов задания этих свойств.

Введение

В этом разделе содержатся сведения о проблемах, которые могут возникнуть при переносе графиков, пакетов и библиотек в Dynamo 3.x.

Dynamo 3.0 — это основной выпуск, в котором изменены или удалены некоторые API. Самое большое изменение, которое может повлиять на работу разработчиков или пользователей Dynamo 3.x, — это переход на .NET8.

Dotnet/.NET — это среда выполнения, которая обеспечивает поддержку языка C#, на котором написана программа Dynamo. Мы перешли на современную версию этой среды вместе с другими компонентами экосистемы Autodesk.

Подробности можно узнать в .

Совместимость пакетов

Использование пакетов Dynamo 2.x в Dynamo 3.x

Поскольку Dynamo 3.x теперь работает на базе среды выполнения .NET8, то работа пакетов, созданных для Dynamo 2.x (с использованием .NET48), в Dynamo 3.x не гарантирована. При попытке скачать пакет в Dynamo 3.x, который был опубликован в версии Dynamo, предшествующей 3.0, отображается предупреждение о том, что пакет взят из более ранней версии Dynamo.

Это не означает, что пакет не будет работать. Это просто предупреждение о возможных проблемах совместимости. В целом, рекомендуется проверить наличие более поздней версии, специально предназначенной для Dynamo 3.x.

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

Использование пакетов Dynamo 3.x в Dynamo 2.x

Маловероятно, что пакет, созданный для Dynamo 3.x (с использованием .Net8), будет работать в Dynamo 2.x. При скачивании пакетов, созданных для более поздних версий Dynamo, в более ранней версии также отображается предупреждение.

Узлы на основе NodeModel обеспечивают гораздо больше гибкости и мощности, чем узлы Zero-Touch. В этом примере мы улучшим узел сетки Zero-Touch, добавив встроенный ползунок, который случайным образом изменяет размер прямоугольника.

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

Шаблон Model-View-Viewmodel

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

• Класс NodeModel для определения основной логики узла (модель).

• Класс INodeViewCustomization для настройки способа просмотра NodeModel (вид).

У объектов NodeModel уже есть связанная пара модели и вида (NodeViewModel), поэтому мы можем сосредоточиться только на модели и виде для пользовательского интерфейса.

Реализация NodeModel

Узлы NodeModel имеют несколько существенных отличий от узлов Zero-Touch. Мы рассмотрим их на следующем примере. Прежде чем мы перейдем к настройке пользовательского интерфейса, создадим логику NodeModel.

1. Создадим структуру проекта.

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

1. Выберите File > New > Project (Файл > Создать > Проект).

2. Выберите Other Project Types (Другие типы проектов), чтобы открыть параметр решения.

3. Выберите Blank Solution (Пустое решение).

4. Присвойте решению имя CustomNodeModel.

5. Нажмите Ok.

Создайте два проекта библиотеки классов C# в решении: один для функций, а другой для реализации интерфейса NodeModel.

1. Щелкните правой кнопкой мыши на решении и выберите Add > New Project (Добавить > Новый проект).

2. Выберите библиотеку классов.

3. Присвойте ей имя CustomNodeModel.

4. Нажмите Ok

5. Повторите процедуру, чтобы добавить другой проект, с именем CustomNodeModelFunctions.

Теперь необходимо переименовать библиотеки классов, которые были созданы автоматически, и добавить их в проект CustomNodeModel. Класс GridNodeModel реализует абстрактный класс NodeModel, GridNodeView используется для настройки вида, а GridFunction содержит все функции, которые необходимо вызвать.

1. Добавьте другой класс: щелкните правой кнопкой мыши проект CustomNodeModel, нажмите Add > New Item... (Добавить > Новый элемент) и выберите Class (Класс).

2. В проекте CustomNodeModel нам необходимы классы GridNodeModel.cs и GridNodeView.cs.

3. В проекте CustomNodeModelFunction требуется класс GridFunctions.cs.

Прежде чем добавить к классам код, добавьте необходимые пакеты для этого проекта. Для CustomNodeModel потребуются ZeroTouchLibrary и WpfUILibrary, а для CustomNodeModelFunction — только ZeroTouchLibrary. WpfUILibrary будет использоваться в настройке адаптации пользовательского интерфейса, а ZeroTouchLibrary будет использоваться для создания геометрии. Пакеты можно добавлять для проектов по отдельности. Так как эти пакеты имеют зависимости, будут автоматически установлены Core и DynamoServices.

1. Щелкните проект правой кнопкой мыши и выберите Manage NuGet Packages (Управлять пакетами NuGet).

2. Установите только необходимые пакеты для данного проекта.

Visual Studio скопирует пакеты NuGet, на которые мы ссылались в каталоге сборки. Для этого параметра можно установить значение false, чтобы в пакете не было ненужных файлов.

1. Выберите пакет Dynamo NuGet.

2. Задайте для параметра Copy Local (Скопировать локально) значение false.

2. Наследование от класса NodeModel.

Как упоминалось ранее, основное отличие узла NodeModel от узла ZeroTouch заключается в реализации класса NodeModel. Узлу NodeModel требуется несколько функций из этого класса, и их можно получить, добавив :NodeModel после имени класса.

Скопируйте следующий код в GridNodeModel.cs.

В этом отличие от Zero-Touch. Давайте попробуем разобраться, что делает каждый элемент.

• Задайте атрибуты узла, такие как имя, категория, имена и типы InPort/OutPort (входящего и выходящего портов), описания.

• public class GridNodeModel : NodeModel — это класс, наследующий класс NodeModel от класса Dynamo.Graph.Nodes.

• public GridNodeModel() { RegisterAllPorts(); } является конструктором, регистрирующим входные и выходные данные узла.

• BuildOutputAst() возвращает AST (абстрактное синтаксическое дерево) — необходимую структуру для возврата данных из узла NodeModel.

• AstFactory.BuildFunctionCall() вызывает функцию RectangularGrid из GridFunctions.cs.

• new Func<int, int, double, List<Rectangle>>(GridFunction.RectangularGrid) задает функцию и ее параметры.

• new List<AssociativeNode> { inputAstNodes[0], inputAstNodes[1], sliderValue }); сопоставляет входные данные узла с параметрами функции.

• AstFactory.BuildNullNode() создает пустой узел, если входные порты не подключены. Это позволяет избежать отображения предупреждения на узле.

• RaisePropertyChanged("SliderValue") уведомляет пользовательский интерфейс об изменении значения ползунка.

• var sliderValue = AstFactory.BuildDoubleNode(SliderValue) создает узел AST, представляющий значение ползунка.

• Измените входные данные на переменную sliderValue в переменной functionCall new List<AssociativeNode> { inputAstNodes[0], sliderValue });.

3. Вызов функции.

Проект CustomNodeModelFunction будет создан в отдельной сборке из CustomNodeModel, чтобы его можно было вызвать.

Скопируйте следующий код в GridFunction.cs.

Этот класс функций очень похож на пример использования Zero-Touch Grid, но есть одно отличие:

• При указании [IsVisibleInDynamoLibrary(false)] Dynamo не видит следующий метод и класс, поскольку функция уже вызывается из CustomNodeModel.

Так же как мы добавили ссылки на пакеты NuGet, CustomNodeModel должен будет ссылаться на CustomNodeModelFunction для вызова функции.

Оператор using для CustomNodeModel будет неактивен до тех пор, пока мы не сошлемся на функцию.

1. Щелкните правой кнопкой мыши CustomNodeModel и выберите Add > Reference (Добавить > Ссылка).

2. Выберите Projects > Solution (Проекты > Решение).

3. Выберите CustomNodeModelFunction.

4. Нажмите Ok

4. Настройка вида.

Чтобы создать ползунок, необходимо настроить пользовательский интерфейс, реализовав интерфейс INodeViewCustomization.

Скопируйте следующий код в GridNodeView.cs.

• public class CustomNodeModelView : INodeViewCustomization<GridNodeModel> определяет функции, необходимые для настройки пользовательского интерфейса.

После настройки структуры проекта используйте среду разработки Visual Studio, чтобы собрать пользовательский элемент управления и определить его параметры в файле .xaml. В окне инструментов добавьте ползунок в элемент <Grid>...</Grid>.

1. Щелкните правой кнопкой мыши CustomNodeModel и выберите Add > New Item (Добавить > Новый элемент).

2. Выберите WPF.

3. Присвойте пользовательскому элементу управления имя Slider (Ползунок).

4. Нажмите Add (Добавить).

Скопируйте следующий код в Slider.xaml.

• Параметры ползунка определяются в файле .xaml. Атрибуты минимума и максимума определяют числовой диапазон этого ползунка.

• Внутри <Grid>...</Grid> можно разместить различные пользовательские элементы управления с панели инструментов Visual Studio.

При создании файла Slider.xaml Visual Studio был автоматически создан файл C# с именем Slider.xaml.cs, который инициализирует ползунок. Измените пространство имен в этом файле.

• Нам требуется пространство имен CustomNodeModel.CustomNodeModel.

GridNodeModel.cs определяет логику вычисления ползунка.

5. Настройка пакета.

Перед сборкой проекта добавьте файл pkg.json, чтобы Dynamo мог прочитать пакет.

1. Щелкните правой кнопкой мыши CustomNodeModel и выберите Add > New Item (Добавить > Новый элемент).

2. Выберите Web (Веб).

3. Выберите JSON File (Файл JSON).

4. Присвойте файлу имя pkg.json.

5. Нажмите Add (Добавить).

• Скопируйте следующий код в pkg.json.

• "name": определяет имя пакета и его группу в библиотеке Dynamo.

• "keywords": предоставляет условия поиска по библиотеке Dynamo.

• "node_libraries": [] — библиотеки, связанные с пакетом

  Последний шаг — собрать решение и опубликовать его в виде пакета Dynamo. Сведения о создании локального пакета перед публикацией в Интернете и о сборке пакета непосредственно в Visual Studio см. в разделе «Развертывание пакета».

Расширения в виде пакетов

Обзор

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

Структура пакета

Структура пакета расширения совпадает со структурой обычного пакета.

Если расширение уже собрано, то у вас уже должны быть сборка .NET и файл манифеста. Сборка должна содержать класс, который реализует IViewExtension или IExtension. XML-файл манифеста указывает Dynamo, какой класс следует создать для запуска расширения. Чтобы диспетчер пакетов нашел расширение, файл манифеста должен точно соответствовать расположению и имени сборки.

Все файлы сборки можно поместить в папку bin, а файл манифеста — в папку extra. В эту папку также можно поместить любые дополнительные компоненты.

Пример файла манифеста XML.

Выгрузка

После создания папки, содержащей указанные выше подкаталоги, ее можно передать (выгрузить) в диспетчер пакетов. Следует помнить, что в настоящее время невозможно публиковать пакеты из Dynamo Sandbox. Это означает, что необходимо использовать Dynamo Revit. В Dynamo Revit перейдите в раздел Packages > Publish New Package (Пакеты > Опубликовать новый пакет). При этом пользователю будет предложено войти в свою учетную запись Autodesk, с которой требуется связать пакет.

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

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

Извлечение

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

Публикация пакета

Пакеты — это удобный способ хранения узлов и предоставления к ним доступа сообществу Dynamo. В пакет можно поместить любые элементы: от пользовательских узлов, созданных в рабочем пространстве Dynamo, до производных узлов NodeModel. Пакеты публикуются и устанавливаются с помощью диспетчера пакетов. Дополнительные сведения о пакетах см. в .

Что такое диспетчер пакетов?

Диспетчер пакетов Dynamo — это программный реестр (похожий на npm), который можно открыть из Dynamo или в веб-браузере. Диспетчер пакетов обеспечивает установку, публикацию, обновление и просмотр пакетов. Как и npm, он поддерживает различные версии пакетов. Кроме того, он помогает управлять зависимостями проекта.

В браузере найдите пакеты и просмотрите статистику:

• В Dynamo диспетчер пакетов обеспечивает установку, публикацию и обновление пакетов.

1. Поиск пакетов в Интернете: Packages > Search for a Package... (Пакеты > Поиск пакета).

2. Просмотр/редактирование установленных пакетов: Packages > Manage Packages... (Пакеты > Управлять пакетами).

3. Публикация нового пакета: Packages > Publish New Package... (Пакеты > Опубликовать новый пакет).

Публикация пакетов

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

Запустите Dynamo и выберите Packages > Publish New Package... (Пакеты > Опубликовать новый пакет), чтобы открыть окно Publish a Package (Опубликовать пакет).

1. Выберите Add file... (Добавить файл) для поиска файлов, которые требуется добавить в пакет.

2. Выберите два файла .dll из примера NodeModel.

3. Нажмите Ok.

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

Пакет готов к публикации.

1. Введите требуемые сведения: имя, описание и версию.

2. Чтобы опубликовать файл, нажмите кнопку «Опубликовать локально» и выберите папку пакета Dynamo: AppData\Roaming\Dynamo\Dynamo Core\1.3\packages. Узел будет доступен в Core. Всегда публикуйте пакет локально до тех пор, пока он не будет готов к публикации в открытом доступе.

После публикации пакета узлы будут доступны в библиотеке Dynamo в категории CustomNodeModel.

1. Пакет, созданный в библиотеке Dynamo

Когда пакет будет готов к публикации в Интернете, откройте диспетчер пакетов и выберите Publish (Опубликовать), а затем Publish Online (Опубликовать в Интернете).

1. Чтобы узнать, как пакет был отформатирован в Dynamo, щелкните значок с тремя точками справа от CustomNodeModel и выберите Show Root Directory (Показать корневой каталог).

2. Выберите Publish (Опубликовать), а затем Publish Online (Опубликовать в Интернете) в окне публикации пакета Dynamo.

3. Чтобы удалить пакет, выберите Delete (Удалить).

Как обновить пакет?

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

1. Выберите Publish Version (Публикация версии), чтобы дополнить существующий пакет новыми файлами в корневом каталоге, а затем выберите, следует ли опубликовать пакет локально или в Интернете.

Веб-клиент диспетчера пакетов

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

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

Пример расширения

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

1. Окно расширения вида, созданное в соответствии с примером SampleViewExtension в репозитории Github.

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

В этом пошаговом руководстве мы будем ссылаться на проект SampleViewExtension, который находится в папке DynamoSamples/src/.

Реализация расширения вида

Расширение вида состоит из трех основных частей:

• сборка, содержащая класс, который реализует IViewExtension, а также класс, который создает модель вида.

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

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

1. Создание структуры проекта

Начните с создания нового проекта Class Library (Библиотека классов) с именем SampleViewExtension.

1. Создайте новый проект, выбрав File > New > Project (Файл > Создать > Проект).

2. Выберите Class Library (Библиотека классов).

3. Присвойте проекту имя SampleViewExtension.

4. Нажмите Ok.

В этом проекте нам потребуется два класса. Один класс будет реализовывать IViewExtension, а другой, который реализует NotificationObject. IViewExtension, будет содержать все сведения о развертывании, загрузке, ссылке и удалении расширения. NotificationObject будет предоставлять уведомления об изменениях в Dynamo, а IDisposable будет обновлять количество при внесении изменений.

1. Файл класса с именем SampleViewExtension.cs, который будет реализовывать IViewExtension.

2. Файл класса с именем SampleWindowViewMode.cs, который будет реализовывать NotificationObject.

Для использования IViewExtension нам потребуется пакет NuGet WpfUILibrary. При установке этого пакета будут автоматически установлены пакеты Core, Services и ZeroTouchLibrary.

1. Выберите библиотеку WpfUILibrary.

2. Нажмите Install (Установить) для установки всех зависимых пакетов.

2. Реализация класса IViewExtension

В классе IViewExtension мы определим, что происходит при запуске Dynamo, при загрузке расширения и при завершении работы Dynamo. В файл класса SampleViewExtension.cs добавьте следующий код:

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

• public class SampleViewExtension : IViewExtension SampleViewExtension наследуется из интерфейса IViewExtension и предоставляет все необходимое для создания пункта меню.

• sampleMenuItem = new MenuItem { Header = "Show View Extension Sample Window" }; создает MenuItem (Пункт меню) и добавляет его в меню View (Вид).

1. Пункт меню

• sampleMenuItem.Click += (sender, args) инициирует событие, которое откроет новое окно при нажатии пункта меню.

• MainGrid = { DataContext = viewModel } задает контекст данных для основной сетки в окне, ссылаясь на Main Grid в создаваемом файле .xaml.

• Owner = p.DynamoWindow назначает Dynamo владельцем всплывающего окна. Это означает, что новое окно находится в зависимости от Dynamo, поэтому при сворачивании, развертывании и восстановлении Dynamo те же действия будут выполняться с новым окном.

• window.Show(); отображает окно, в котором заданы дополнительные свойства.

3. Реализация модели вида

Определив некоторые основные параметры окна, добавим логику для реагирования на различные события, связанные с Dynamo, а также поставим для пользовательского интерфейса задачу обновления данных в соответствии с этими событиями. Скопируйте следующий код в файл класса SampleWindowViewModel.cs:

Эта реализация класса модели вида прослушивает CurrentWorkspaceModel и инициирует событие при добавлении или удалении узла из рабочего пространства. При этом происходит изменение свойства, которое уведомляет пользовательский интерфейс или связанные элементы о том, что данные были изменены и их необходимо обновить. Метод получения ActiveNodeTypes вызывает дополнительную вспомогательную функцию getNodeTypes(). Эта функция проходит по всем активным узлам в рабочей области, заполняет строку, содержащую имена этих узлов, и возвращает эту строку в нашу привязку в файле XAML, чтобы она отобразилась в нашем всплывающем окне.

Теперь, когда определена основная логика расширения, мы зададим параметры отображения окна с помощью файла .xaml. Нам нужно простое окно, в котором будет отображаться строка с помощью привязки свойства ActiveNodeTypes в TextBlock Text.

1. Щелкните проект правой кнопкой мыши и выберите Add > New Item... (Добавить > Новый элемент).

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

3. Присвойте новому файлу имя SampleWindow.xaml.

4. Нажмите Add (Добавить).

В коде окна .xaml нам потребуется привязать SelectedNodesText к текстовому блоку. Добавьте следующий код в файл SampleWindow.xaml:

• Text="{Binding ActiveNodeTypes}" привязывает значение свойства ActiveNodeTypes в SampleWindowViewModel.cs к значению TextBlock Text в окне.

Теперь инициализируем окно образца в файле резервной копии XAML C# SampleWindow.xaml.cs. Добавьте следующий код в файл SampleWindow.xaml:

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

1. Щелкните проект правой кнопкой мыши и выберите Add > New Item... (Добавить > Новый элемент).

2. Выберите файл XML.

3. Присвойте файлу имя SampleViewExtension_ViewExtensionDefinition.xml.

4. Нажмите Add (Добавить).

• Имя файла соответствует стандарту Dynamo для ссылки на сборку расширения: "extensionName"_ViewExtensionDefinition.xml

В файле xml добавьте следующий код, указывающий Dynamo, где искать сборку расширения:

• В этом примере сборка была создана в папке проекта Visual Studio по умолчанию. Замените целевое расположение <AssemblyPath>...</AssemblyPath> на путь к сборке.

Наконец, скопируйте файл SampleViewExtension_ViewExtensionDefinition.xml в папку расширений видов Dynamo, расположенную в каталоге установки Dynamo Core C:\Program Files\Dynamo\Dynamo Core\1.3\viewExtensions. Важно отметить, что для extensions и viewExtensions существуют отдельные папки. Если разместить файл xml в неправильной папке, во время выполнения может произойти сбой загрузки.

1. Файл .xml, скопированный в папку расширений видов Dynamo.

Это основная информация о расширениях видов. Более сложный пример можно найти в пакете DynaShape, проекте с открытым исходным кодом на GitHub. Пакет использует расширение вида, которое позволяет редактировать модель Dynamo в реальном времени.

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

Репозиторий примеров

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

• ZeroTouchEssentials: шаблон для базовых узлов ZeroTouch.

  • Возвращение нескольких выходных данных: код

  • Использование исходного геометрического объекта из Dynamo: код

  • Пример свойства (узел запроса): код

• HelloDynamo: шаблоны для базовых узлов NodeModel и персонализации вида.

  • Базовый шаблон NodeModel: HelloNodeModel.cs

    • Определение атрибутов узла (имена, описание и типы входных и выходных данных): код

    • Возвращение пустого узла, если нет входных данных: код

    • Создание вызова функции: код

  • Шаблон персонализации базового вида NodeModel: HelloGui.cs, HelloGuiNodeView.cs, Slider.xaml, Slider.xaml.cs

    • Предупреждение о необходимости обновления элемента в пользовательском интерфейсе: код

    • Персонализация NodeModel: код

    • Определение атрибутов регулятора: код

    • Определение логики взаимодействия для регулятора: код

• DynamoSamples: шаблоны для ZeroTouch, персонализированного пользовательского интерфейса, тестов и расширений видов.

  • Примеры API

    • Создание базового узла персонализированного пользовательского интерфейса: CustomNodeModel.cs.

    • Создание раскрывающегося меню: DropDown.cs.

  • Тесты

    • Системные тесты: HelloDynamoSystemTests.cs

    • Тесты ZeroTouch: HelloDynamoZeroTouchTests.cs

  • Примеры ZeroTouch:

    • Пример узлов ZeroTouch, включая реализацию IGraphicItem с целью повлиять на визуализацию геометрии: BasicExample.cs.

    • Пример узлов ZeroTouch для раскрашивания геометрии с помощью IRenderPackage: ColorExample.cs

  • Примеры расширений видов: реализация IViewExtension, которая отображает немодальное окно при нажатии на элемент MenuItem.

• NodeModelsEssentials: шаблоны для расширенной разработки пакетов Dynamo с помощью NodeModel.

  • Важные примеры:

    • Ошибка

    • MultiOperation

    • Умножение

    • Timeout

  • Примеры геометрии:

    • CustomPreview

    • SurfaceFrom4Points

    • UVPlanesOnSurface

    • WobblySurface

  • Примеры пользовательского интерфейса:

    • Кнопка

    • ButtonFunction

    • CopyableWatch

    • Регулятор

    • SliderBound

    • Состояние

DynaText: библиотека ZeroTouch для создания текста в Dynamo.

Примеры

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

Ladybug — это библиотека Python для загрузки, анализа и изменения файлов EneregyPlus Weather (epw).

https://github.com/ladybug-tools/ladybug

Honeybee — это библиотека Python для создания, запуска и визуализации результатов расчета естественного освещения (RADIANCE) и энергопотребления (EnergyPlus/OpenStudio).

https://github.com/ladybug-tools/honeybee

Bumblebee — подключаемый модуль для совместимости Excel и Dynamo (GPL).

https://github.com/ksobon/Bumblebee

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

https://github.com/andydandy74/ClockworkForDynamo

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

Требования к запросам на слияние

Команда Dynamo ожидает, что запросы на слияние будут соответствовать следующим требованиям.

• Придерживайтесь стандартов кодировки и стандартов именования узлов.

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

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

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

Чего не следует делать:

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

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

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

• добавлять дополнения к API без отправки проблемы и предварительного обсуждения с нами.

Заполнение шаблона запроса на слияние

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

• После такого запроса на слияние состояние базы кода улучшится.

• Документация соответствует стандартам.

• Все необходимые тесты прилагаются.

• Пользовательские строки, если таковые имеются, извлекаются в файлы *.resx.

• Все тесты можно выполнить с использованием конвейера непрерывной интеграции с самообслуживанием.

• Снимок изменений пользовательского интерфейса, если таковые имеются.

• Изменения в API соответствуют принципам семантического управления версиями и записаны в документе Изменения API.

Команда Dynamo назначит рецензента для запроса на слияние.

Процесс проверки запроса на слияние

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

• Группа разработчиков Dynamo проводит встречи для рассмотрения запросов на слияние раз в месяц, и рассмотрение начинается с наиболее ранних.

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

• Запросы на слияние должны соответствовать шаблону Dynamo по умолчанию.

• Запросы на слияние, в которых не полностью заполнены шаблоны Dynamo и выполнены не все условия, не рассматриваются.

Отбор фиксаций для Dynamo Revit

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