Dynamo의 소스는 누구나 복제하고 기여할 수 있도록 Github에 호스팅됩니다. 이 장에서는 git을 사용하여 리포지토리를 복제하고, Visual Studio에서 소스 파일을 컴파일하고, 로컬 빌드를 실행 및 디버깅하고, Github에서 새로운 변경 사항을 끌어오는 방법을 살펴봅니다.

Github에서 Dynamo 리포지토리 찾기

Github는 변경 사항을 추적하고 작업자 간 작업을 조정하기 위한 버전 관리 시스템인 git을 기반으로 하는 호스팅 서비스입니다. git은 Dynamo의 소스 파일을 다운로드하고 몇 가지 명령으로 소스 파일을 지속적으로 업데이트하는 데 활용할 수 있는 도구입니다. 이 방법을 사용하면 업데이트할 때마다 소스 파일을 다운로드하고 수동으로 바꾸는 불필요하고 번거로운 작업을 피할 수 있습니다. git 버전 관리 시스템은 로컬 코드 리포지토리와 원격 코드 리포지토리 간의 차이를 추적합니다.

Dynamo의 소스는 https://github.com/DynamoDS/Dynamo 리포지토리의 DynamoDS Github에 호스팅됩니다.

Dynamo 소스 파일입니다.
전체 리포지토리 복제 또는 다운로드
다른 DynamoDS 리포지토리 보기
Dynamo의 소스 파일
Git 관련 파일

git을 사용하여 Dynamo 리포지토리 끌어오기

리포지토리를 복제하려면 먼저 git을 설치해야 합니다. 설치 단계 및 gihub 사용자 이름 및 이메일을 설정하는 방법에 대해서는 이 간략한 안내서를 따르십시오. 이 예에서는 명령행에서 git을 사용할 것입니다. 이 안내서에서는 Windows를 사용한다고 가정하지만, mac 또는 linux에서도 git을 사용하여 Dynamo 소스를 복제할 수 있습니다.

복제할 Dynamo 리포지토리의 URL을 파악해야 합니다. 이 기능은 리포지토리 페이지의 "복제 또는 다운로드" 버튼에서 찾을 수 있습니다. URL을 복사하여 명령 프롬프트에 붙여넣습니다.

"복제 또는 다운로드"를 선택합니다.
URL을 복사합니다.

git이 설치되어 있으면 Dynamo 리포지토리를 복제할 수 있습니다. 명령 프롬프트를 열어서 시작합니다. 그런 다음 디렉토리 변경 명령 cd를 사용하여 소스 파일을 복제할 폴더를 탐색합니다. 여기에서는 Documents에 Github라는 폴더를 생성했습니다.

cd C:\Users\username\Documents\GitHub

"username"을 사용자 이름으로 바꿉니다.

다음 단계에서는 git 명령을 실행하여 Dynamo 리포지토리를 지정한 위치에 복제합니다. 명령의 URL은 Github에서 "복제 또는 다운로드" 버튼을 클릭하여 확인할 수 있습니다. 명령 터미널에서 이 명령을 실행합니다. 그러면 Dynamo의 가장 최신 업데이트 코드인 Dynamo 리포지토리 마스터 분기가 복제되고 최신 버전의 Dynamo 코드가 포함됩니다. 이 분기는 매일 변경됩니다.

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

복제 작업이 성공적으로 완료되면 git이 잘 작동하는 것입니다. 파일 탐색기에서 복제한 디렉토리로 이동하여 소스 파일을 확인합니다. 디렉토리 구조는 Github의 Dynamo 리포지토리의 마스터 분기와 동일할 것입니다.

Dynamo의 소스 파일
Git 파일

Visual Studio를 사용하여 리포지토리 빌드하기

소스 파일이 로컬 컴퓨터에 복제되면, 이제 Dynamo용 실행 파일을 빌드할 수 있습니다. 이를 위해서는 Visual Studio IDE를 설정하고 .NET Framework 및 DirectX가 설치되어 있는지 확인해야 합니다.

완전한 기능을 갖춘 무료 IDE(통합 개발 환경)인 Microsoft Visual Studio Community 2015(이후 버전도 작동할 수 있음)를 다운로드한 후 설치합니다.
Microsoft .NET Framework 4.5 이상 버전을 다운로드한 후 설치합니다.
로컬 Dynamo 리포지토리에서 Microsoft DirectX(Dynamo\tools\install\Extra\DirectX\DXSETUP.exe)를 설치합니다.

.NET 및 DirectX가 이미 설치되어 있을 수 있습니다.

설치가 모두 완료되면 Visual Studio를 시작하고 Dynamo\src에 있는 Dynamo.All.sln 솔루션을 열 수 있습니다.

File > Open > Project/Solution을 선택합니다.
Dynamo 리포지토리로 이동하여 src 폴더를 엽니다.
Dynamo.All.sln 솔루션 파일을 선택합니다.
Open을 선택합니다.

솔루션을 빌드하려면 먼저 몇 가지 설정을 지정해야 합니다. 먼저 Visual Studio가 디버깅하면서 개발하는 데 도움이 되는 더 많은 정보를 수집할 수 있도록 Dynamo의 디버그 버전을 빌드해야 합니다. 여기서는 AnyCPU를 대상 플랫폼으로 지정하겠습니다.

bin 폴더 안에 폴더가 생성됩니다.
이 예에서는 솔루션 구성으로 Debug를 선택했습니다.
솔루션 플랫폼을 Any CPU로 설정합니다.

프로젝트가 열리면 솔루션을 빌드할 수 있습니다. 이 프로세스를 수행하면 실행할 수 있는 DynamoSandbox.exe 파일이 생성됩니다.

프로젝트를 빌드하면 NuGet 종속성이 복원됩니다.
Build > Build Solution을 선택합니다.
빌드가 성공적으로 수행되어 출력 창에 ==== Build: 69 succeeded, 0 failed, 0 up-to-date, 0 skipped ====와 유사하게 표시되는지 확인합니다.

로컬 빌드 실행하기

Dynamo가 성공적으로 빌드되면 DynamoSandbox.exe 파일이 있는 bin 폴더가 Dynamo 리포지토리에 생성됩니다. 이 예에서는 디버그 옵션을 사용하여 빌드하고 있으므로 실행 파일은 bin\AnyCPU\Debug에 있습니다. 이 파일을 실행하면 Dynamo의 로컬 빌드가 열립니다.

방금 빌드한 DynamoSandbox 실행 파일입니다. 이 실행 파일을 실행하여 Dynamo를 시작합니다.

이제 Dynamo를 위한 개발을 시작할 준비가 거의 완료되었습니다.

다른 플랫폼(예: Linux 또는 OS X)용 Dynamo를 빌드하는 방법에 대한 지침은 이 wiki 페이지를 참조하십시오.

Visual Studio를 사용하여 로컬 빌드 디버깅하기

디버깅은 버그 또는 이슈를 식별하고 가려내고 해결하는 프로세스입니다. Dynamo가 소스에서 성공적으로 빌드되면 Visual Studio의 여러 도구를 사용하여 실행 중인 응용프로그램(예: DynamoRevit 애드인)을 디버깅할 수 있습니다. 또한, 소스 코드를 분석하여 이슈의 근본 원인을 찾거나 현재 실행 중인 코드를 확인할 수 있습니다. Visual Studio에서 코드를 디버깅하고 탐색하는 방법에 대한 자세한 내용은 Visual Studio 문서를 참조하십시오.

독립 실행형 Dynamo 응용프로그램인 DynamoSandbox의 두 가지 디버깅 옵션을 살펴보겠습니다.

Visual Studio에서 직접 Dynamo 빌드 및 시작하기
Visual Studio를 실행 중인 Dynamo 프로세스에 연결하기

Visual Studio에서 Dynamo를 시작하면 필요한 경우 모든 디버깅 세션에 대해 솔루션이 다시 빌드되므로, 소스를 변경하면 디버깅할 때 변경 사항이 포함됩니다. Dynamo.All.sln 솔루션이 열려 있는 상태로 드롭다운 메뉴에서 Debug, AnyCPU 및 DynamoSandbox를 선택한 다음 Start를 클릭합니다. 이렇게 하면 Dynamo가 빌드되고 새 프로세스(DynamoSandbox.exe)가 시작되고 Visual Studio의 디버거가 이 프로세스에 연결됩니다.

Visual Studio에서 직접 응용프로그램 빌드 및 시작하기
구성을 Debug로 설정합니다.
플랫폼을 Any CPU로 설정합니다.
시작 프로젝트를 DynamoSandbox로 설정합니다.
Start를 클릭하여 디버깅 프로세스를 시작합니다.

또는 특정 그래프가 열려 있거나 패키지에 대한 이슈를 해결하기 위해 이미 실행 중인 Dynamo 프로세스를 디버깅할 수도 있습니다. 이렇게 하려면 Visual Studio에서 프로젝트의 소스 파일을 열고 Attach to Process 디버그 메뉴 항목을 사용하여 실행 중인 Dynamo 프로세스에 연결합니다.

실행 중인 프로세스를 Visual Studio에 연결하기
Debug > Attach to Process...를 선택합니다.
DynamoSandbox.exe를 선택합니다.
Attach를 선택합니다.

두 상황에서 모두 디버깅하려는 프로세스에 디버거를 연결하겠습니다. 디버거를 시작하기 전이나 후에 코드에서 중단점을 설정하여 해당 코드 줄을 실행하기 직전에 프로세스가 중지되도록 할 수 있습니다. 디버깅하는 동안 예기치 않은 예외가 발생하면 Visual Studio는 소스 코드에서 예외가 발생한 위치로 이동됩니다. 이 방법은 단순한 충돌과 처리되지 않은 예외를 찾고 응용프로그램의 실행 흐름을 파악하는 데 효율적입니다.

DynamoSandbox를 디버깅하는 동안, 노드가 인스턴스화될 때 Dynamo 프로세스가 일시 중지되도록 Color.ByARGB 노드의 생성자에 중단점을 설정했습니다. 이 노드로 인해 예외가 발생하거나 Dynamo가 충돌하는 경우 생성자의 각 줄을 단계별로 실행하여 이슈가 발생한 위치를 찾을 수 있습니다.
중단점
현재 실행 중인 함수와 이전 함수 호출을 보여 주는 호출 스택

다음 섹션인 소스에서 DynamoRevit 빌드하기에서는 디버깅 관련 예를 안내하고, 중단점을 설정하고 코드를 단계별로 실행하고 호출 스택을 읽는 방법에 대해 설명합니다.

소스에서 DynamoRevit 빌드하기

개발자가 기여하고 베타 버전을 빌드할 수 있도록 DynamoRevit 소스 파일도 DynamoDS Github에 호스팅됩니다. 소스에서 DynamoRevit을 빌드하는 작업은 몇 가지 중요한 세부 사항을 제외하고는 일반적으로 Dynamo와 동일한 프로세스를 따릅니다.

DynamoRevit은 Dynamo 어셈블리를 참조하므로 일치하는 NuGet 패키지를 사용하여 빌드해야 합니다. 예를 들어, DynamoRevit 2.x는 Dynamo 1.3에 로드되지 않습니다.
DynamoRevit은 Revit 버전에 따라 따릅니다. 예를 들어, DynamoRevit 2018 분기는 Revit 2018에서 실행되어야 합니다.

이 안내서에서는 다음을 사용합니다.

Revit 2023
분기 Revit2023의 최신 DynamoRevit 빌드
최신 Dynamo 빌드

성공적으로 빌드할 수 있도록 이 연습에서 사용할 Dynamo 및 DynamoRevit 리포지토리를 모두 복제하고 빌드할 것입니다.

참고: Dynamo 1.x 및 DynamoRevit 1.x를 빌드하는 경우에만 Dynamo를 수동으로 빌드해야 합니다. 최신 버전의 DynamoRevit 리포지토리에서는 빌드하는 데 필요한 Dynamo 종속성을 위해 NuGet 패키지 관리자를 사용합니다. DynamoRevit 2.x 빌드에서는 Dynamo를 수동으로 끌어올 필요가 없지만 실제로 DynamoRevit addin 을 실행하려면 다른 곳에 여전히 코어 dlls 가 필요하므로 Dynamo를 끌어오고 빌드하는 것이 좋습니다. 자세한 내용은 아래에 나오는 Visual Studio를 사용하여 리포지토리 빌드를 참조하십시오.

Github에서 DynamoRevit 리포지토리 찾기

DynamoRevit 프로젝트에 대한 코드는 핵심 Dynamo 소스 코드와는 별도로 Github의 리포지토리에 있습니다. 이 리포지토리에는 Revit 전용 노드에 대한 소스 파일과 Dynamo를 로드하는 Revit 애드인이 포함되어 있습니다. 다른 버전의 Revit(예: 2016, 2017 또는 2018)용 DynamoRevit 빌드는 리포지토리에 분기로 구성됩니다.

DynamoRevit 소스는 https://github.com/DynamoDS/DynamoRevit에 호스팅됩니다.

리포지토리 복제 또는 다운로드
DynamoRevit의 분기는 Revit 버전을 참조합니다.

git을 사용하여 리포지토리 복제하기

Dynamo 리포지토리를 끌어오는 것과 유사한 프로세스로 git 복제 명령을 사용하여 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를 사용하여 리포지토리 빌드하기

리포지토리를 빌드하기 전에 src 폴더에 있는 restorepackages.bat 파일을 사용하여 NuGet 패키지를 복원해야 합니다. 이 bat 파일은 nuget 패키지 관리자를 사용하여 Dynamo Revit에 필요한 Dynamo 코어의 빌드된 바이너리를 끌어옵니다. DynamoRevit만 변경하고 Dynamo 코어는 변경하지 않는 경우에는 이러한 바이너리를 수동으로 빌드하도록 선택할 수도 있습니다. 이렇게 하면 더 빠르게 시작할 수 있습니다. 이 파일을 관리자 권한으로 실행해야 합니다.

마우스 오른쪽 버튼으로 restorepackages.bat를 클릭하여 Run as administrator를 선택합니다.

패키지가 성공적으로 복원되면 최신 베타 NuGet 패키지가 있는 packages 폴더가 src 폴더에 추가됩니다.

최신 베타 Dynamo NuGet 패키지

패키지가 복원되면 src에서 DynamoRevit.All.sln Visual Studio 솔루션 파일을 열고 솔루션을 빌드합니다. 빌드 초기에는 AssemblySharedInfo.cs를 찾는 데 어려움이 있을 수 있습니다. 이러한 경우 빌드를 다시 실행하면 이 이슈가 해결됩니다.

Build > Build Solution을 선택합니다.
출력 창에서 빌드가 성공적으로 수행되었는지 확인합니다. ===== Build: 13 succeeded, 0 failed, 0 up-to-date, 0 skipped =====라는 메시지가 표시되어야 합니다.

Revit에서 DynamoRevit의 로컬 빌드 실행하기

Revit은 설치 프로그램이 자동으로 생성하는 애드인 파일이 있어야 DynamoRevit을 인식할 수 있습니다. 개발 단계에서는 사용할 DynamoRevit 빌드, 특히 DynamoRevitDS.dll 어셈블리를 가리키는 애드인 파일을 수동으로 생성해야 합니다. 또한 DynamoRevit이 Dynamo의 빌드를 가리키도록 지정해야 합니다.

C:\ProgramData\Autodesk\Revit\Addins\2023에 있는 Revit의 애드인 폴더에 Dynamo.addin 파일을 생성합니다. 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>

<Assembly>...</Assembly> 안으로 DynamoRevitDS.dll의 파일 경로를 지정합니다.

애드인에서 특정 어셈블리 대신 버전 선택기를 로드하도록 할 수도 있습니다.

<?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>은 위에서 어셈블리 요소 경로로 지정한 어셈블리에서 인스턴스화할 클래스를 지정합니다. 이 클래스는 애드인의 시작점이 될 것입니다.

또한 Revit과 함께 제공되는 기존 Dynamo를 제거해야 합니다. 이를 위해 C:\\Program Files\Autodesk\Revit 2023\AddIns 로 이동하여 Dynamo - DynamoForRevit 및 DynamoPlayerForRevit이 포함된 두 개의 폴더를 제거합니다. 원래 Dynamo for Revit을 복구해야 하는 경우 개별 폴더에서 삭제하거나 백업할 수 있습니다.

두 번째 단계는 Dynamo 코어 어셈블리의 파일 경로를 DynamoRevit의 bin 폴더에 있는 Dynamo.config 파일에 추가하는 것입니다. DynamoRevit은 애드인이 Revit에서 열릴 때 이러한 파일을 로드합니다. 이 구성 파일을 사용하면 DynamoRevit 애드인이 Dynamo 코어의 다른 버전을 가리키도록 지정하여 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>

bin 폴더의 디렉토리 경로를 <add key/>에 추가합니다.

이 연습을 시작하기 직전에 Dynamo를 복제하고 빌드하여 DynamoRevit과 잘 연동되는지 확인했습니다. 디렉토리 경로는 이 빌드를 가리킵니다.

이제 Revit을 열면 관리 탭에 Dynamo 애드인이 있습니다.

Manage를 선택합니다.
Dynamo 애드인 아이콘을 클릭합니다.
DynamoRevit의 인스턴스

누락된 어셈블리가 표시된 오류 대화상자 창이 나타나면 빌드한 DynamoCore 버전과 런타임 시 로드하는 버전이 일치하지 않는 것일 수 있습니다. 예를 들어, 최신 2.0 베타 패키지의 DynamoCore가 포함된 DynamoRevit은 Dynamo 1.3 dlls를 사용하여 시작하려고 하면 작동하지 않습니다. 두 리포지토리의 버전이 동일하고 DynamoRevit이 일치하는 버전의 nuget 종속성을 끌어오고 있는지 확인합니다. 이것은 DynamoRevit 리포지토리의 package.json 파일에 정의되어 있습니다.

Visual Studio를 사용하여 DynamoRevit 디버깅하기

이전 섹션인 소스에서 Dynamo 빌드하기에서는 Visual Studio에서 디버깅하는 방법과 Visual Studio를 프로세스에 연결하는 방법을 간략하게 설명했습니다. Wall.ByCurveAndHeight 노드의 예외를 예로 들어, 프로세스에 연결하고, 중단점을 설정하고, 코드를 단계별로 실행하고, 호출 스택을 사용하여 예외의 소스를 확인하는 방법을 살펴보겠습니다. 이러한 디버깅 도구는 일반적으로 .net 개발 워크플로우에 적용되며 다른 리소스를 통해 살펴볼 가치가 있습니다.

프로세스에 연결은 디버깅을 위해 실행 중인 응용프로그램을 Visual Studio에 연결합니다. DynamoRevit 빌드에서 발생하는 동작을 디버깅하려면 Visual Studio에서 DynamoRevit 소스 파일을 열고 DynamoRevit 애드인의 상위 프로세스인 Revit.exe 프로세스를 연결하면 됩니다. Visual Studio는 기호 파일(.pbd)을 사용하여 DynamoRevit이 실행 중인 어셈블리와 소스 코드를 연결합니다.
중단점은 소스 코드에서 응용프로그램이 실행되기 전에 일시 중지되는 줄을 설정합니다. 노드로 인해 DynamoRevit이 충돌하거나 예기치 않은 결과가 반환되는 경우, 노드 소스에 중단점을 추가하여 프로세스를 일시 중지하고, 코드를 한 단계씩 실행하고, 문제의 근본 원인을 찾을 때까지 변수의 실시간 값을 검사할 수 있습니다
단계별로 코드 실행하기는 소스를 한 줄씩 실행합니다. 함수를 하나씩 실행하거나, 함수 호출을 한 단계씩 실행하거나, 현재 실행 중인 함수에서 나갈 수 있습니다.
호출 스택은 이 함수 호출을 호출한 이전 함수 호출과 관련하여 프로세스가 현재 실행 중인 함수를 표시합니다. Visual Studio에는 이러한 함수를 표시하는 호출 스택 창이 있습니다. 예를 들어, 소스 코드 외부의 예외에 도달하면 호출 스택에서 호출 코드에 대한 경로를 볼 수 있습니다.
C#에 대해 알아야 할 2,000가지 사항에서 호출 스택에 대해 더 자세히 알아볼 수 있습니다.

Wall.ByCurveAndHeight 노드는 곡선 입력으로 PolyCurve가 지정되면 "BSPlineCurve까지가 구현되지 않음" 이라는 메시지와 함께 예외를 발생시킵니다. 디버깅을 통해 노드가 이 형상 유형을 곡선 매개변수의 입력으로 허용하지 않는 이유를 정확히 파악할 수 있습니다. 이 예에서는 DynamoRevit이 성공적으로 빌드되어 Revit용 애드인으로 실행할 수 있다고 가정합니다.

예외를 발생시키는 Wall.ByCurveAndHeight 노드

먼저 DynamoRevit.All.sln 솔루션 파일을 열고 Revit을 시작한 다음 DynamoRevit 애드인을 시작합니다. 그런 다음 Attach to Process 창을 사용하여 Visual Studio를 Revit 프로세스에 연결합니다.

사용 가능한 프로세스로 표시하려면 Revit과 DynamoRevit이 실행 중이어야 합니다.
Debug > Attach to Process...를 선택하여 Attach to Process 창을 엽니다.
Transport을 Default로 설정합니다.
Revit.exe를 선택합니다.
Attach를 선택합니다.

Visual Studio가 Revit에 연결된 상태로 Wall.cs에서 Wall.ByCurveAndHeight 소스 코드를 엽니다. 솔루션 탐색기에서 파일의 Public static constructors 영역에 있는 Libraries > RevitNodes > Elements 아래에서 찾을 수 있습니다. 벽 유형의 생성자에서 중단점을 설정하여 Dynamo에서 노드가 실행될 때 프로세스가 중단되고 코드의 각 줄을 개별적으로 실행해 볼 수 있도록 합니다. 일반적으로 Dynamo zero touch 유형 생성자는 By<parameters>로 시작합니다.

Wall.ByCurveAndHeight의 생성자가 있는 클래스 파일
줄 번호 왼쪽을 클릭하거나 코드 줄을 마우스 오른쪽 버튼으로 클릭하여 중단점을 설정하고 Breakpoint > Insert Breakpoint를 선택합니다.

중단점을 설정한 후에는 Wall.ByCurveAndHeight 함수를 통해 프로세스를 실행해야 합니다. 포트 중 하나에 와이어를 다시 연결하면 노드가 강제로 다시 실행되므로, 이 함수를 다시 실행할 수 있습니다. 중단점이 Visual Studio에서 적중됩니다.

중단점 아이콘은 적중되면 변경됩니다.
다음 메서드를 보여주는 호출 스택 창이 표시됩니다.

이제 예외에 도달할 때까지 생성자의 각 줄을 실행합니다. 노란색으로 강조 표시된 코드가 다음에 실행될 문입니다.

코드 탐색용 디버깅 도구
Step Over를 눌러 강조 표시된 코드를 실행한 다음 함수가 반환되면 실행을 일시 중단합니다.
실행할 다음 문은 노란색 강조 표시 및 화살표로 표시됩니다.

함수를 계속 실행하면 DynamoRevit 창에 발생한 예외가 표시됩니다. 호출 스택 창을 보면 예외가 Autodesk.Revit.CurveAPIUtils.CreateNurbsCurve라는 메서드에서 처음 발생했음을 알 수 있습니다. 다행히도 예외는 여기에서 처리되므로 Dynamo에서 충돌이 발생하지 않았습니다. 디버깅 프로세스는 소스 코드의 다른 메서드로 이동하여 이슈에 대한 컨텍스트를 제공했습니다.

이 라이브러리는 오픈 소스 라이브러리가 아니므로 변경할 수 없습니다. 지금까지 많은 정보를 살펴보았으므로, 이제 더 많은 컨텍스트와 함께 github 이슈를 제기하여 이슈를 보고하거나 끌어오기 요청을 통해 이 이슈에 대한 해결 방법을 제안할 수 있습니다.

Walls.cs에서 예외를 유발하는 문에 도달하면 디버깅 프로세스를 통해 ProtoToRevitCurve.cs 내의 사용자 코드에서 이슈의 근본 원인에 최대한 가깝게 이동할 수 있습니다
예외를 유발하는 문은 ProtoToRevitCurve.cs입니다.
호출 스택에서 예외가 비사용자 코드에서 발생하는 것을 확인할 수 있습니다.
예외에 대한 정보를 제공하는 팝업 창이 표시됩니다.

이 프로세스는 작업 중인 모든 소스 파일에 적용할 수 있습니다. Dynamo Studio용 Zero-Touch 노드 라이브러리를 개발하는 경우 라이브러리의 소스를 열고 Dynamo 프로세스를 연결하여 노드 라이브러리를 디버깅할 수 있습니다. 모든 것이 완벽하게 작동하더라도 디버깅은 코드를 탐색하고 작동 방식을 파악할 수 있는 유용한 방법입니다.

Dynamo를 위한 개발

경험 수준에 관계없이 Dynamo 플랫폼은 모든 사용자가 기여할 수 있도록 설계되었습니다. 다양한 능력과 기술 수준을 대상으로 하는 여러 가지 개발 옵션이 있으며, 각 개발 옵션은 목표에 따라 장단점이 있습니다. 아래에서는 여러 옵션에 대해 간략하게 알아보고 하나의 옵션을 선택하는 방법에 대해 살펴보겠습니다.

세 가지 개발 환경: Visual Studio, Python 편집기 및 코드 블록 DesignScript

어떤 옵션이 제공됩니까?

Dynamo의 개발 옵션은 주로 두 가지 카테고리인 for Dynamo와 in Dynamo로 나뉩니다. 두 가지 카테고리는 다음과 같이 생각할 수 있습니다. "in" Dynamo는 Dynamo IDE를 사용하여 생성한 콘텐츠를 Dynamo에서 사용하는 것을 의미하며, "for" Dynamo는 외부 도구를 사용하여 생성한 콘텐츠를 Dynamo로 가져와서 사용하는 것을 의미합니다. 이 안내서는 for Dynamo 개발에 중점을 두고 있지만, 아래에 모든 프로세스에 대한 리소스가 명시되어 있습니다.

For Dynamo

이러한 노드를 사용하면 최고 수준으로 사용자 지정할 수 있습니다. 많은 패키지가 이 방법으로 빌드되며, 이것은 Dynamo의 소스에 기여하는 데 필요합니다. 패키지를 빌드하는 프로세스는 이 안내서에 설명되어 있습니다.

Zero-Touch 노드
NodeModel 파생 노드
확장

입문서에는 Zero-Touch 라이브러리 가져오기와 관련된 안내서가 있습니다.

아래 설명에서는 Visual Studio를 Zero-Touch 및 NodeModel 노드의 개발 환경으로 사용합니다.

Visual Studio 인터페이스와 개발 예정인 프로젝트

In Dynamo

이러한 프로세스는 시각적 프로그래밍 작업공간에 존재하고 비교적 간단하지만, 모두 Dynamo를 사용자 지정하는 데 사용할 수 있는 옵션입니다. 입문서는 이러한 내용을 광범위하게 다루고 있으며 스크립팅 전략 장에서 스크립팅 팁과 활용 사례를 제공합니다.

코드 블록은 시각적 프로그래밍 환경에서 DesignScript를 노출하여 유연한 텍스트 스크립트 및 노드 워크플로우를 지원합니다. 코드 블록의 함수는 작업공간의 모든 항목에서 호출할 수 있습니다.
코드 블록 예제를 다운로드하거나(마우스 오른쪽 버튼을 클릭하고 다른 이름으로 저장) 입문서에서 자세한 내용을 참조하십시오.
사용자 지정 노드는 노드 모음 또는 전체 그래프를 위한 컨테이너로, 자주 사용하는 루틴을 수집하고 커뮤니티와 공유하는 효과적인 방법입니다.
사용자 지정 노드 예제를 다운로드하거나(마우스 오른쪽 버튼을 클릭하고 다른 이름으로 저장) 입문서에서 자세한 내용을 참조하십시오.
Python 노드는 코드 블록과 유사한, 시각적 프로그래밍 작업공간의 스크립팅 인터페이스입니다. Autodesk.DesignScript 라이브러리는 DesignScript와 유사한 점 표기법을 사용합니다.
Python 노드 예제를 다운로드하거나(마우스 오른쪽 버튼을 클릭하고 다른 이름으로 저장) 입문서에서 자세한 내용을 참조하십시오.

Dynamo 작업공간을 통한 개발은 피드백을 즉각적으로 받을 수 있는 강력한 도구입니다.

Python 노드를 사용하여 Dynamo 작업공간에서 개발하기

장점과 단점은 각각 무엇입니까?

Dynamo의 개발 옵션은 복잡한 사용자 지정 요구 사항을 해결하기 위해 설계되었습니다. Python으로 재귀 스크립트를 작성하든 완전히 사용자 지정 가능한 노드 UI를 빌드하든, 시작하고 실행하는 데 필요한 것만 포함하는 코드를 구현할 수 있는 옵션이 있습니다.

Dynamo의 코드 블록, Python 노드 및 사용자 지정 노드

아래에 Dynamo 시각적 프로그래밍 환경에서 코드를 작성할 수 있는 간단한 옵션이 나와 있습니다. Dynamo 시각적 프로그래밍 작업공간은 Python과 DesignScript에 대한 액세스와 사용자 지정 노드 안에 여러 노드를 포함할 수 있는 기능을 제공합니다.

이러한 방법을 사용하여 다음을 수행할 수 있습니다.

설정이 거의 또는 전혀 없는 Python 또는 DesignScript를 작성합니다.
Python 라이브러리를 Dynamo로 가져옵니다.
코드 블록, Python 노드 및 사용자 지정 노드를 패키지의 일부로 Dynamo 커뮤니티와 공유합니다.

Zero-Touch 노드

Zero-Touch는 간단한 포인트 앤 클릭 방법으로 C# 라이브러리를 가져오는 것을 의미합니다. Dynamo에서는 .dll의 공용 메서드를 읽고 Dynamo 노드로 변환합니다. Zero-Touch를 사용하여 사용자 지정 노드 및 패키지를 개발할 수 있습니다.

이 방법을 사용하여 다음을 수행할 수 있습니다.

Dynamo용으로 개발되지 않았을 수 있는 라이브러리를 가져와서 입문서에 나와 있는 A-Forge 예제와 같은 새로운 노드의 모음을 자동으로 작성합니다.
C# 메서드를 작성하고 Dynamo에서 메서드를 노드로 손쉽게 사용합니다.
C# 라이브러리를 패키지의 노드로 Dynamo 커뮤니티와 공유합니다.

NodeModel 파생 노드

이러한 노드는 Dynamo 구조에서 한 단계 더 들어간 것으로, NodeModel 클래스를 기반으로 하며 C#으로 작성되었습니다. 이 방법이 가장 뛰어난 유연성과 강력한 성능을 제공하기는 하지만, 노드의 대부분의 측면을 명시적으로 정의해야 하고 함수는 별도의 어셈블리에 있어야 합니다.

이 방법을 사용하여 다음을 수행할 수 있습니다.

슬라이더, 이미지, 색상 등을 사용하여 완전히 사용자 지정 가능한 노드 UI를 생성합니다(예: ColorRange 노드)
Dynamo 캔버스에서 발생하는 사항에 액세스하고 관련 작업을 수행합니다.
레이싱을 사용자 지정합니다.
Dynamo에 패키지로 로드합니다.

Dynamo 버전 관리 및 API 변경 사항 이해하기(1.x → 2.x)

Dynamo는 정기적으로 업데이트되고 있으므로 패키지에서 사용하는 API의 일부가 변경될 수 있습니다. 기존 패키지가 계속 제대로 작동하도록 하려면 이러한 변경 사항을 추적하는 것이 중요합니다.

API 변경 사항은 Dynamo Github Wiki에서 추적할 수 있습니다. 이러한 변경 사항에는 DynamoCore, 라이브러리 및 작업공간에 대한 변경 사항이 포함됩니다.

버전 2.0에서 파일 형식이 XML에서 JSON으로 전환될 예정이며, 이는 예정된 중요 변경 사항 중 하나입니다. NodeModel 파생 노드에는 이제 JSON 생성자가 필요하며, 이 생성자가 없으면 Dynamo 2.0에서 열리지 않습니다.

현재 Dynamo의 API 문서(http://dynamods.github.io/DynamoAPI)에는 핵심 기능에 대한 설명이 포함되어 있습니다.

패키지에 바이너리를 배포할 수 있는 권한

패키지 관리자에 업로드되는 패키지에 .dll이 포함되어 있는지 확인합니다. 패키지 작성자가 .dll을 생성하지 않은 경우, 패키지 작성자에게 해당 .dll을 공유할 수 있는 권한이 있어야 합니다.

패키지에 바이너리가 포함되어 있는 경우 다운로드할 때 사용자에게 패키지에 바이너리가 포함되어 있다는 메시지가 표시되어야 합니다.

시작하기

개발 단계로 넘어가기 전에 새 프로젝트를 위한 강력한 기반을 구축하는 것이 중요합니다. Dynamo 개발자 커뮤니티에는 시작할 때 사용할 수 있는 유용한 여러 프로젝트 템플릿이 있지만, 프로젝트를 처음부터 시작하는 방법을 이해하는 것이 훨씬 더 중요합니다. 프로젝트를 처음부터 새로 구축하면 개발 프로세스를 더 깊이 이해할 수 있습니다.

Visual Studio 프로젝트 생성하기

Visual Studio는 프로젝트를 생성하고, 참조를 추가하고, .dlls를 빌드하고, 디버깅할 수 있는 강력한 IDE입니다. Visual Studio에서 새 프로젝트를 생성하면 프로젝트를 구성하기 위한 구조인 솔루션도 생성됩니다. 하나의 솔루션 내에 여러 프로젝트가 존재할 수 있으며 여러 프로젝트를 함께 구축할 수 있습니다. ZeroTouch 노드를 만들려면 C# 클래스 라이브러리를 작성하고 .dll을 빌드할 새 Visual Studio 프로젝트를 시작해야 합니다.

Visual Studio의 새 프로젝트 창
먼저 Visual Studio를 열고 새 프로젝트를 생성합니다. 이를 위해 File > New > Project로 이동합니다.
Class Library 프로젝트 템플릿을 선택합니다.
프로젝트 이름을 지정합니다(여기서는 프로젝트 이름을 MyCustomNode로 지정함).
프로젝트의 파일 경로를 설정합니다. 이 예에서는 기본 위치를 사용할 것입니다.
Ok를 선택합니다.

Visual Studio에서 자동으로 C# 파일을 생성하고 엽니다. 적절한 이름을 지정하고 작업공간을 설정한 다음 기본 코드를 이 곱하기 메서드로 바꿔야 합니다.

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

View에서 솔루션 탐색기 및 출력 창을 엽니다.
오른쪽의 솔루션 탐색기에서 Class1.cs 파일의 이름을 SampleFunctions.cs로 바꿉니다.
곱하기 함수에 대한 위의 코드를 추가합니다. Dynamo에서 C# 클래스를 읽는 방법에 대해서는 나중에 자세히 다룰 것입니다.
솔루션 탐색기: 프로젝트의 모든 항목에 액세스할 수 있습니다.
출력 창: 나중에 이 창에서 빌드가 성공했는지 확인할 수 있습니다.

다음 단계는 프로젝트를 빌드하는 것이지만, 그 전에 몇 가지 설정을 확인해야 합니다. 먼저, Any CPU 또는 x64가 플랫폼 대상으로 선택되었고 프로젝트 특성에서 Prefer 32-bit가 선택 취소되어 있는지 확인합니다.

Project > "ProjectName" Properties를 선택하여 프로젝트 특성을 엽니다.
Build 페이지를 선택합니다.
드롭다운 메뉴에서 Any CPU 또는 x64를 선택합니다.
Prefer 32-bit가 선택 취소되어 있는지 확인합니다.

이제 프로젝트를 빌드하여 .dll을 생성할 수 있습니다. 이렇게 하려면 Build 메뉴에서 Build Solution을 선택하거나 단축키 CTRL+SHIFT+B를 사용합니다.

Build > Build Solution을 선택합니다.
출력 창에서 프로젝트가 성공적으로 빌드되었는지 확인할 수 있습니다

프로젝트가 성공적으로 빌드된 경우 프로젝트의 bin 폴더에 이름이 MyCustomNode인 .dll이 있습니다. 이 예에서는 프로젝트의 파일 경로로 Visual Studio의 기본값인 c:\users\username\documents\visual studio 2015\Projects를 사용했습니다. 프로젝트의 파일 구조를 살펴보겠습니다.

bin 폴더에는 Visual Studio에서 빌드된 .dll이 포함되어 있습니다.
Visual Studio 프로젝트 파일
클래스 파일
솔루션 구성이 Debug로 설정되었으므로 .dll은 bin\Debug에 생성됩니다.

이제 Dynamo를 열고 .dll을 가져올 수 있습니다. 추가 기능을 사용하여 프로젝트의 bin 위치로 이동한 후 .dll을 선택하여 엽니다.

추가 버튼을 선택하여 .dll을 가져옵니다.
프로젝트 위치로 이동합니다. 프로젝트는 Visual Studio의 기본 파일 경로인 C:\Users\username\Documents\Visual Studio 2015\Projects\MyCustomNode에 있습니다.
가져올 MyCustomNode.dll을 선택합니다.
Open을 클릭하여 .dll을 로드합니다.

MyCustomNode라는 라이브러리에 카테고리가 생성되면 .dll을 성공적으로 가져온 것입니다. 하지만, 우리는 하나의 노드만 만들려고 했는데 Dynamo에서 두 개의 노드를 만들었습니다. 다음 섹션에서는 이러한 상황이 발생하는 이유와 Dynamo에서 .dll을 읽는 방법에 대해 설명합니다.

Dynamo 라이브러리의 MyCustomNode. 라이브러리 범주는 .dll 이름에 따라 결정됩니다.
캔버스의 SampleFunctions.MultiplyByTwo

Dynamo에서 클래스 및 메서드를 읽는 방법

Dynamo에서 .dll을 로드하면 모든 공용 정적 메서드가 노드로 노출됩니다. 생성자, 메서드 및 특성은 각각 Create, Action 및 Query 노드로 변환됩니다. 곱하기 예제에서 MultiplyByTwo() 메서드는 Dynamo의 Action 노드가 됩니다. 그 이유는 노드의 이름이 메서드 및 클래스를 기반으로 지정되었기 때문입니다.

입력 이름은 메서드의 매개변수 이름에 따라 inputNumber로 지정됩니다.
출력 이름은 기본적으로 double로 지정되는데, 그 이유는 double이 반환되는 데이터 유형이기 때문입니다.
노드의 이름은 클래스 및 메서드 이름에 해당하는 SampleFunctions.MultiplyByTwo로 지정됩니다.

위의 예에서는 생성자를 명시적으로 제공하지 않아 생성자가 자동으로 생성되었기 때문에 추가 SampleFunctions Create 노드가 만들어졌습니다. SampleFunctions 클래스에서 빈 Private 생성자를 생성하면 이 문제를 방지할 수 있습니다.

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;
        }
    }
}

Dynamo에서 Create 노드로 메서드를 가져왔습니다.

Dynamo NuGet 패키지 참조 추가하기

곱하기 노드는 매우 간단하므로 Dynamo에 대한 참조가 필요하지 않습니다. 예를 들어 형상을 작성하기 위해 Dynamo의 기능에 액세스하려면 Dynamo NuGet 패키지를 참조해야 합니다.

ZeroTouchLibrary - DynamoUnits.dll, ProtoGeometry.dll 라이브러리가 포함된 Dynamo용 Zero-Touch 노드 라이브러리를 빌드하기 위한 패키지
WpfUILibrary - DynamoCoreWpf.dll, CoreNodeModels.dll, CoreNodeModelWpf.dll 라이브러리가 포함된 WPF에서 사용자 지정 UI를 사용하여 Dynamo용 노드 라이브러리를 빌드하기 위한 패키지
DynamoServices - Dynamo용 DynamoServices 라이브러리
코어 - DSIronPython.dll, DynamoApplications.dll, DynamoCore.dll, DynamoInstallDetective.dll, DynamoShapeManager.dll, DynamoUtilities.dll, ProtoCore.dll, VMDataBridge.dll 라이브러리가 포함된 Dynamo용 단위 및 시스템 테스트 인프라
테스트 - DynamoCoreTests.dll, SystemTestServices.dll, TestServices.dll 라이브러리가 포함된 Dynamo용 단위 및 시스템 테스트 인프라
DynamoCoreNodes - Analysis.dll, GeometryColor.dll, DSCoreNodes.dll 라이브러리가 포함된 Dynamo용 코어 노드를 빌드하기 위한 패키지

Visual Studio 프로젝트에서 이러한 패키지를 참조하려면 위 링크의 NuGet에서 패키지를 다운로드하고 수동으로 .dlls를 참조하거나 Visual Studio에서 NuGet 패키지 관리자를 사용하십시오. 먼저 Visual Studio에서 NuGet을 사용하여 이러한 패키지를 설치하는 방법을 살펴보겠습니다.

Tools > NuGet Package Manager > Manage NuGet Packages for Solution...을 선택하여 NuGet 패키지 관리자를 엽니다.

NuGet Package Manager입니다. 이 창에는 프로젝트를 위해 설치된 패키지가 표시되며, 사용자는 다른 패키지를 찾아볼 수 있습니다. 새 버전의 DynamoServices 패키지가 릴리즈되면 여기에서 패키지를 업데이트하거나 이전 버전으로 되돌릴 수 있습니다.

찾아보기를 선택하고 DynamoVisualProgramming을 검색하여 Dynamo 패키지를 시작합니다.
Dynamo 패키지. 패키지를 선택하면 현재 버전과 버전에 대한 설명이 표시됩니다.
필요한 패키지 버전을 선택하고 설치를 클릭합니다. 그러면 작업 중인 특정 프로젝트에 대한 패키지가 설치됩니다. 현재 안정적인 최신 릴리즈인 Dynamo 1.3 버전을 사용하고 있으므로, 해당 패키지 버전을 선택합니다.

브라우저에서 다운로드한 패키지를 수동으로 추가하려면 솔루션 탐색기에서 참조 관리자를 열고 패키지를 찾습니다.

마우스 오른쪽 버튼으로 References를 클릭하고 Add Reference를 선택합니다.
패키지 위치로 이동하려면 Browse를 선택합니다.

Visual Studio가 올바르게 구성되었고 Dynamo에 .dll을 성공적으로 추가했으므로, 개념을 이해하기 위한 확고한 토대를 갖추게 되었습니다. 이것은 시작에 불과하므로, 계속 진행하면서 사용자 지정 노드를 만드는 방법에 대해 자세히 알아보십시오.

Zero-Touch 사례 연구 - 그리드 노드

Visual Studio 프로젝트를 실행한 상태에서 직사각형의 셀 그리드를 만드는 사용자 지정 노드를 빌드하는 방법을 살펴봅니다. 여러 표준 노드를 사용하여 이 노드를 생성할 수 있지만, 이 노드는 Zero-Touch 노드에 쉽게 포함할 수 있는 유용한 도구입니다. 그리드 선과 달리 셀은 중심점을 기준으로 크기를 조정하거나, 모서리 정점을 조회하거나, 면에 내장될 수 있습니다.

이 예에서는 Zero-Touch 노드를 생성할 때 주의해야 할 몇 가지 기능 및 개념에 대해 다룹니다. 사용자 지정 노드를 빌드하여 Dynamo에 추가한 후에는 ‘Zero-Touch로 한 단계 더 나아가기’ 페이지를 검토하여 기본 입력 값, 여러 값 반환, 문서, 객체, Dynamo 형상 유형 사용 및 마이그레이션에 대해 자세히 살펴보십시오.

사용자 지정 직사각형 그리드 노드

그리드 노드 빌드를 시작하려면 새 Visual Studio 클래스 라이브러리 프로젝트를 생성합니다. 프로젝트를 설정하는 방법에 대한 자세한 설명은 시작하기 페이지를 참조하십시오.

프로젝트 유형으로 Class Library를 선택합니다.
프로젝트의 이름을 CustomNodes로 지정합니다.

형상을 작성하고 있으므로 적절한 NuGet 패키지를 참조해야 합니다. Nuget Package Manager에서 ZeroTouchLibrary 패키지를 설치합니다. 이 패키지는 using Autodesk.DesignScript.Geometry; 문에 필요합니다.

ZeroTouchLibrary 패키지를 찾아봅니다.
Dynamo Studio의 현재 빌드인 1.3에서 이 노드를 사용할 것입니다. 이 버전과 일치하는 패키지 버전을 선택합니다.
클래스 파일의 이름도 Grids.cs로 변경했습니다.

다음으로, RectangularGrid 메서드가 위치할 네임스페이스 및 클래스를 설정해야 합니다. Dynamo에서 노드의 이름은 메서드 및 클래스 이름에 따라 지정됩니다. 아직 Visual Studio로 복사하지 않아도 됩니다.

Autodesk.DesignScript.Geometry;는 ZeroTouchLibrary 패키지의 ProtoGeometry.dll을 참조하며 System.Collections.Generic은 리스트를 작성하는 데 필요합니다.

이제 직사각형을 그리는 메서드를 추가할 수 있습니다. 클래스 파일은 다음과 같아야 하며 Visual Studio로 복사할 수 있습니다.

프로젝트가 이와 비슷하면 .dll을 빌드해 봅니다.

빌드 > 솔루션 빌드를 선택합니다.

프로젝트의 bin 폴더에 .dll이 있는지 확인합니다. 빌드가 성공하면 Dynamo에 .dll을 추가할 수 있습니다.

Dynamo 라이브러리의 사용자 지정 RectangularGrids 노드
캔버스의 사용자 지정 노드
Dynamo에 .dll을 추가하기 위한 추가 버튼

사용자 지정 노드 수정

위의 예에서는 RectangularGrids 메서드 외에 다른 것을 정의하지 않은 매우 간단한 노드를 만들었습니다. 그러나 입력 포트에 대한 툴팁을 작성하거나 표준 Dynamo 노드처럼 노드에 요약을 제공할 수 있습니다. 이러한 기능을 사용자 지정 노드에 추가하면 특히 사용자가 라이브러리에서 기능을 검색하려는 경우 더 쉽게 사용할 수 있습니다.

기본 입력 값
xCount 입력에 대한 툴팁

RectangularGrid 노드에는 다음과 같은 기본 기능이 필요합니다. 아래 코드에서 입력 및 출력 포트 설명, 요약 및 기본 입력 값을 추가했습니다.

RectangularGrid(int xCount = 10, int yCount = 10)와 같이 메서드 매개변수에 값을 할당하여 입력 기본값을 지정합니다.
앞에 ///가 오는 XML 문서로 입력 및 출력 툴팁, 검색 키워드 및 요약을 작성합니다.

툴팁을 추가하려면 프로젝트 디렉토리에 xml 파일이 있어야 합니다. 이 옵션을 사용하면 Visual Studio에서 .xml을 자동으로 생성할 수 있습니다.

여기에서 XML 문서 파일을 사용하도록 설정하고 파일 경로를 지정합니다. 그러면 XML 파일이 생성됩니다.

모두 끝났습니다. 여러 표준 기능을 사용하여 새 노드를 만들었습니다. 다음 장에서는 Zero-Touch 노드 개발 및 알아야 할 이슈에 대해 자세히 설명합니다.

Zero-Touch 노드에서 Python 스크립트 실행하기(C#)

Python에서 스크립트를 작성하는 데 익숙하고 표준 Dynamo Python 노드에서 더 많은 기능을 사용하고자 하는 경우 Zero-Touch를 사용하여 자체 노드를 만들 수 있습니다. Python 스크립트를 문자열로 Zero-Touch 노드에 전달하여 스크립트가 실행되고 결과가 반환되는 간단한 예로 시작하겠습니다. 이 사례 연구는 연습과 시작하기 섹션의 예제를 기반으로 합니다. Zero-Touch 노드를 만드는 것이 완전히 처음인 경우 해당 섹션을 참조하십시오.

Python 스크립트 문자열을 실행할 Zero-Touch 노드

Python 엔진

이 노드는 IronPython 스크립팅 엔진의 인스턴스에 의존합니다. 이를 위해서는 몇 개의 추가 어셈블리를 참조해야 합니다. 아래 단계에 따라 Visual Studio에서 기본 템플릿을 설정합니다.

새 Visual Studio 클래스 프로젝트를 생성합니다.
C:\Program Files (x86)\IronPython 2.7\IronPython.dll에 있는 IronPython.dll에 참조를 추가합니다.
C:\Program Files (x86)\IronPython 2.7\Platforms\Net40\Microsoft.Scripting.dll에 있는 Microsoft.Scripting.dll에 참조를 추가합니다.
클래스에 IronPython.Hosting 및 Microsoft.Scripting.Hosting using 문을 포함합니다.
추가 노드가 패키지와 함께 Dynamo 라이브러리에 추가되지 않도록 빈 Private 생성자를 추가합니다.
단일 문자열을 입력 매개변수로 사용하는 새 메서드를 생성합니다.
이 메서드 내에서 새 Python 엔진을 인스턴스화하고 빈 스크립트 범위를 생성합니다. 이 범위를 Python 해석기의 인스턴스 내에 있는 전역 변수라고 생각하면 됩니다.
다음으로, 입력 문자열 및 범위를 매개변수로 전달하여 엔진에 대해 Execute를 호출합니다
마지막으로, 범위에 대해 GetVariable을 호출하고 반환하려는 값이 포함된 Python 스크립트의 변수 이름을 전달하여 스크립트 결과를 검색하고 반환합니다. (자세한 내용은 아래 예를 참조하십시오.)

다음 코드는 위에서 언급한 단계의 예를 제공합니다. 솔루션을 빌드하면 프로젝트의 bin 폴더에 새 .dll이 생성됩니다. 이제 이 .dll을 패키지의 일부로 또는 File < Import Library...로 이동하여 Dynamo로 가져올 수 있습니다.

여러 출력

표준 Python 노드의 한 가지 한계는 출력 포트가 하나뿐이므로 여러 객체를 반환하려면 리스트를 구성하고 각 객체를 가져와야 한다는 것입니다. 위의 예를 수정하여 사전을 반환하는 경우 원하는 만큼 출력 포트를 추가할 수 있습니다. 사전에 대한 자세한 내용은’ Zero-Touch로 한 단계 더 나아가기’의 여러 값 반환하기 섹션을 참조하십시오.

이 노드를 사용하면 직육면체의 체적과 중심을 모두 반환할 수 있습니다.

다음 단계를 수행하여 이전 예를 수정해 보겠습니다.

NuGet 패키지 관리자에서 DynamoServices.dll에 참조를 추가합니다.
이전 어셈블리에는 System.Collections.Generic 및 Autodesk.DesignScript.Runtime도 포함되어 있습니다.
메서드의 반환 유형을 수정하여 출력이 포함될 사전을 반환합니다.
각 출력은 범위에서 개별적으로 검색해야 합니다(더 큰 출력 세트의 경우 간단한 루프를 설정하는 것이 좋음).

샘플 Python 스크립트에 추가 출력 변수(output2)도 추가했습니다. 이러한 변수는 모든 합법적인 Python 명명 규칙을 사용할 수 있으며, 이 예에서는 명확성을 위해 출력을 정확하게 사용했습니다.

Zero-Touch로 한 단계 더 나아가기

Zero-Touch 프로젝트를 생성하는 방법을 이해했다면 Dynamo Github의 ZeroTouchEssentials 예를 통해 노드를 만드는 방법에 대한 세부 사항을 파악할 수 있습니다.

위에 나와 있는 대부분의 Math, Color 및 DateTime 노드와 마찬가지로 Dynamo의 표준 노드 대부분은 기본적으로 Zero-Touch 노드입니다.

시작하려면 에서 ZeroTouchEssentials 프로젝트를 다운로드하십시오.

Visual Studio에서 ZeroTouchEssentials.sln 솔루션 파일을 열고 솔루션을 빌드합니다.

ZeroTouchEssentials.cs 파일에는 Dynamo로 가져올 모든 메서드가 포함되어 있습니다.

다음 예제에서 참조할 노드를 가져오기 위해 Dynamo를 열고 ZeroTouchEssentials.dll을 가져옵니다.

기본 입력 값

메서드 매개변수를 기본값인 inputNumber = 2.0으로 설정합니다.

노드 입력 포트 위에 마우스 포인터를 놓으면 기본값이 표시됩니다.

여러 값 반환하기

여러 값을 반환하는 것은 여러 입력을 생성하는 것보다 조금 더 복잡하며 사전을 사용하여 반환해야 합니다. 사전의 항목은 노드의 출력 쪽에 있는 포트가 됩니다. 다음과 같은 방법으로 여러 개의 반환 포트가 생성됩니다.

Dictionary<>를 사용하려면 using System.Collections.Generic;을 추가합니다.
MultiReturn 속성을 사용하려면 using Autodesk.DesignScript.Runtime;을 추가합니다. 이것은 DynamoServices NuGet 패키지의 "DynamoServices.dll"을 참조합니다.
메서드에 [MultiReturn(new[] { "string1", "string2", ... more strings here })] 속성을 추가합니다. 문자열은 사전의 키를 참조하며 출력 포트 이름이 됩니다.
속성의 매개변수 이름과 일치하는 키가 있는 함수 return new Dictionary<string, object>에서 Dictionary<>를 반환합니다.

여러 출력을 반환하는 노드.

이제 사전의 키에 입력한 문자열에 따라 이름이 지정된 두 개의 출력 포트가 있음을 알 수 있습니다.

문서, 툴팁 및 검색

노드의 함수, 입력, 출력, 검색 태그 등을 설명하는 문서를 Dynamo 노드에 추가하는 것이 좋습니다. 이 작업은 XML 문서 태그를 통해 수행되고, XML 문서는 다음과 같은 방법으로 생성됩니다.

슬래시 3개가 앞에 오는 설명 텍스트는 문서로 간주됩니다.
- 예: /// Documentation text and XML goes here
슬래시 세 개 뒤에 Dynamo가 .dll을 가져올 때 읽을 메서드 위에 XML 태그를 생성합니다.
- 예: /// <summary>...</summary>
Project > Project Properties > Build를 선택하고 XML documentation file을 확인하여 Visual Studio에서 XML 문서를 사용하도록 설정합니다.

Visual Studio에서 지정된 위치에 XML 파일을 생성합니다.

태그 유형은 다음과 같습니다.

/// <summary>...</summary>는 노드의 기본 문서이며 왼쪽 검색 사이드바의 노드 위에 툴팁으로 표시됩니다.
/// <param name="inputName">...</param>은 특정 입력 매개변수에 대한 문서를 작성합니다.
/// <returns>...</returns>는 출력 매개변수에 대한 문서를 생성합니다.
/// <returns name = "outputName">...</returns>는 여러 출력 매개변수에 대한 문서를 생성합니다.
/// <search>...</search>는 쉼표로 구분된 목록을 기반으로 검색 결과와 노드를 일치시킵니다. 예를 들어, 메쉬를 구획화하는 노드를 만드는 경우 "mesh", "subdivision" 및 "catmull-clark"와 같은 태그를 추가할 수 있습니다.

다음은 입력 및 출력 설명과 라이브러리에 표시되는 요약이 포함된 노드 예입니다.

이 노드 예의 코드에는 다음이 포함되어 있습니다.

노드 요약
입력 설명
출력 설명

객체

Dynamo에는 new 키워드가 없으므로 정적 구성 방법을 사용하여 객체를 구성해야 합니다. 객체는 다음과 같은 방식으로 구성됩니다.

다른 요구 사항이 없는 한 생성자를 내부 internal ZeroTouchEssentials()로 만듭니다.
public static ZeroTouchEssentials ByTwoDoubles(a, b)와 같은 정적 메서드로 객체를 구성합니다.

참고: Dynamo는 정적 메서드가 생성자임을 나타내는 접두사 "By"를 사용합니다. 선택 사항이지만 "By"를 사용하면 라이브러리를 기존 Dynamo 스타일에 더 잘 맞도록 할 수 있습니다.

ZeroTouchEssentials dll을 가져오면 라이브러리에 ZeroTouchEssentials 노드가 생성됩니다. 이 객체는 ByTwoDoubles 노드를 사용하여 생성할 수 있습니다.

Dynamo 형상 유형 사용하기

Dynamo 라이브러리는 기본 Dynamo 형상 유형을 입력으로 사용하고 새 형상을 출력으로 생성할 수 있습니다. 형상 유형은 다음과 같은 방식으로 생성됩니다.

C# 파일의 맨 위에 using Autodesk.DesignScript.Geometry;를 포함하고 프로젝트에 ZeroTouchLibrary NuGet 패키지를 추가하여 프로젝트에서 "ProtoGeometry.dll"을 참조합니다.
중요: 함수에서 반환되지 않는 형상 리소스를 관리하려면 아래의 Dispose/using 문 섹션을 참조하십시오.

참고: Dynamo 형상 객체는 함수에 전달된 다른 모든 객체처럼 사용됩니다.

곡선의 길이를 가져와서 두 배로 늘리는 노드

이 노드는 곡선 형상 유형을 입력으로 허용합니다.

Dispose/using 문

함수에서 반환되지 않는 형상 리소스는 Dynamo 버전 2.5 이상을 사용하지 않는 한 수동으로 관리해야 합니다. Dynamo 2.5 이상 버전에서는 형상 리소스가 시스템 내부에서 처리되지만 복잡한 사용 사례가 있거나 결정적인 시간에 메모리를 줄여야 하는 경우 형상을 수동으로 제거해야 할 수 있습니다. Dynamo 엔진은 함수에서 반환되는 모든 형상 리소스를 처리합니다. 반환되지 않는 형상 리소스는 다음과 같은 방법으로 수동으로 처리할 수 있습니다.

using 문:
수동 Dispose 호출:

마이그레이션

최신 버전의 라이브러리를 게시하는 경우 노드 이름이 변경될 수 있습니다. 마이그레이션 파일에 이름 변경 사항을 지정하여 이전 버전의 라이브러리에서 작성된 그래프가 업데이트 시에도 계속 제대로 작동하도록 할 수 있습니다. 마이그레이션은 다음과 같은 방식으로 구현됩니다.

.dll과 동일한 폴더에 "BaseDLLName".Migrations.xml 형식의 .xml 파일을 생성합니다.
.xml에서 하나의 <migrations>...</migrations> 요소를 생성합니다.
이름을 변경할 때마다 마이그레이션 요소 내부에서 <priorNameHint>...</priorNameHint> 요소를 생성합니다.
이름을 변경할 때마다 <oldName>...</oldName> 및 <newName>...</newName> 요소를 제공합니다.

Add > New Item을 마우스 오른쪽 버튼으로 클릭하여 선택합니다.
XML File을 선택합니다.
이 프로젝트의 경우 마이그레이션 파일의 이름을 ZeroTouchEssentials.Migrations.xml로 지정합니다.

이 코드 예는 GetClosestPoint라는 이름의 모든 노드가 이제 ClosestPointTo라는 이름으로 지정되었다는 것을 Dynamo에 알려줍니다.

제네릭

Zero-Touch는 현재 제네릭 사용을 지원하지 않습니다. 제네릭을 사용할 수는 있지만, 유형이 설정되지 않은 경우 직접 가져온 코드에서는 사용할 수 없습니다. 제네릭에 해당하고 유형이 설정되어 있지 않은 메서드, 특성 또는 클래스는 노출할 수 없습니다.

아래 예에서는 T 유형의 Zero-Touch 노드를 가져오지 않습니다. 라이브러리의 나머지 부분을 Dynamo로 가져오면 유형 예외가 누락됩니다.

이 예에서 설정된 유형과 함께 제네릭 유형을 사용하면 Dynamo로 가져올 수 있습니다.

NodeModel 사례 연구 - 사용자 지정 UI

NodeModel 기반 노드는 Zero-Touch 노드보다 훨씬 더 뛰어난 유연성과 강력한 기능을 제공합니다. 이 예에서는 직사각형 크기를 임의 지정하는 통합 슬라이더를 추가하여 Zero-Touch 그리드 노드를 한 단계 높여 보겠습니다.

슬라이더는 셀의 크기를 기준으로 셀의 크기를 조정하므로 사용자가 슬라이더의 범위를 정확하게 지정할 필요가 없습니다.

Model-View-Viewmodel 패턴

Dynamo는 model-view-viewmodel (MVVM) 소프트웨어 아키텍처 패턴을 기반으로 UI를 백엔드와 분리하여 유지합니다. ZeroTouch 노드를 만들 때 Dynamo는 노드의 데이터와 해당 UI 간에 데이터 바인딩을 수행합니다. 사용자 지정 UI를 생성하려면 데이터 바인딩 논리를 추가해야 합니다.

크게 보면 Dynamo에서 모델-뷰 관계를 설정하는 데는 두 가지 부분이 있습니다.

노드의 코어 논리를 설정하는 NodeModel 클래스("모델")
NodeModel이 표시되는 방식을 사용자 지정하는 INodeViewCustomization 클래스("뷰")

NodeModel 객체에는 이미 연관된 뷰-모델(NodeViewModel)이 있으므로 사용자 지정 UI를 위해 모델과 뷰에만 초점을 맞추면 됩니다.

NodeModel을 구현하는 방법

NodeModel 노드는 Zero-Touch 노드와 몇 가지 중요한 차이점이 있으며, 이에 대해서는 이 예에서 다룰 것입니다. UI 사용자 지정으로 넘어가기 전에 NodeModel 논리를 빌드해 보겠습니다.

1. 프로젝트 구조 생성하기:

NodeModel 노드는 함수를 호출할 수만 있으므로 NodeModel 및 함수를 서로 다른 라이브러리로 분리해야 합니다. Dynamo 패키지에 대해 이 작업을 수행하는 표준 방법은 각각에 대해 별도의 프로젝트를 생성하는 것입니다. 먼저 프로젝트를 포괄하는 새 솔루션을 생성합니다.

File > New > Project를 선택합니다.
Other Project Types를 선택하여 솔루션 옵션을 표시합니다.
Blank Solution을 선택합니다.
솔루션의 이름을 CustomNodeModel로 지정합니다.
Ok를 선택합니다.

솔루션에서 C# 클래스 라이브러리 프로젝트 2개(함수용 프로젝트와 NodeModel 인터페이스를 구현하기 위한 프로젝트)를 생성합니다.

솔루션을 마우스 오른쪽 버튼으로 클릭하고 Add > New Project를 선택합니다.
클래스 라이브러리를 선택합니다.
이름을 CustomNodeModel로 지정합니다.
Ok를 클릭합니다.
프로세스를 반복하여 이름이 CustomNodeModelFunctions인 다른 프로젝트를 추가합니다.

다음으로, 자동으로 생성된 클래스 라이브러리의 이름을 바꾸고 하나를 CustomNodeModel 프로젝트에 추가해야 합니다. 클래스 GridNodeModel은 추상 NodeModel 클래스를 구현하고 GridNodeView는 뷰를 사용자 지정하는 데 사용되고, GridFunction에는 호출해야 하는 함수가 포함되어 있습니다.

CustomNodeModel 프로젝트를 마우스 오른쪽 버튼으로 클릭하고 Add > New Item...을 선택한 후 Class를 선택하여 다른 클래스를 추가합니다.
CustomNodeModel 프로젝트에는 GridNodeModel.cs 및 GridNodeView.cs 클래스가 필요합니다.
CustomNodeModelFunction 프로젝트에는 GridFunctions.cs 클래스가 필요합니다.

클래스에 코드를 추가하기 전에 이 프로젝트에 필요한 패키지를 추가합니다. CustomNodeModel에는 ZeroTouchLibrary 및 WpfUILlibrary가 필요하고 CustomNodeModelFunction에는 ZeroTouchLibrary만 필요합니다. WpfUILlibrary는 나중에 UI를 사용자 지정하는 데 사용되며 ZeroTouchLibrary는 형상을 생성하는 데 사용됩니다. 패키지는 프로젝트에 대해 개별적으로 추가할 수 있습니다. 이러한 패키지에는 종속성이 있으므로 Core 및 DynamoServices가 자동으로 설치됩니다.

프로젝트를 마우스 오른쪽 버튼으로 클릭하고 Manage NuGet Packages를 선택합니다.
해당 프로젝트에 필요한 패키지만 설치합니다.

Visual Studio는 빌드 디렉토리에 참조한 NuGet 패키지를 복사합니다. 패키지에 불필요한 파일이 포함되지 않도록 이 값을 false로 설정할 수 있습니다.

Dynamo NuGet 패키지를 선택합니다.
Copy Local를 false로 설정합니다.

2. NodeModel 클래스 상속하기

앞에서 설명한 것처럼 NodeModel 노드가 ZeroTouch 노드와 다른 주요 측면은 NodeModel 클래스의 구현입니다. NodeModel 노드에는 이 클래스의 여러 함수가 필요하며, 클래스 이름 뒤에 :NodeModel을 추가하여 이러한 함수를 가져올 수 있습니다.

다음 코드를 GridNodeModel.cs에 복사합니다.

using System;
using System.Collections.Generic;
using Dynamo.Graph.Nodes;
using CustomNodeModel.CustomNodeModelFunction;
using ProtoCore.AST.AssociativeAST;
using Autodesk.DesignScript.Geometry;

namespace CustomNodeModel.CustomNodeModel
{
    [NodeName("RectangularGrid")]
    [NodeDescription("An example NodeModel node that creates a rectangular grid. The slider randomly scales the cells.")]
    [NodeCategory("CustomNodeModel")]
    [InPortNames("xCount", "yCount")]
    [InPortTypes("double", "double")]
    [InPortDescriptions("Number of cells in the X direction", "Number of cells in the Y direction")]
    [OutPortNames("Rectangles")]
    [OutPortTypes("Autodesk.DesignScript.Geometry.Rectangle[]")]
    [OutPortDescriptions("A list of rectangles")]
    [IsDesignScriptCompatible]
    public class GridNodeModel : NodeModel
    {
        private double _sliderValue;
        public double SliderValue
        {
            get { return _sliderValue; }
            set
            {
                _sliderValue = value;
                RaisePropertyChanged("SliderValue");
                OnNodeModified(false);
            }
        }
        public GridNodeModel()
        {
            RegisterAllPorts();
        }
        public override IEnumerable<AssociativeNode> BuildOutputAst(List<AssociativeNode> inputAstNodes)
        {
            if (!HasConnectedInput(0) || !HasConnectedInput(1))
            {
                return new[] { AstFactory.BuildAssignment(GetAstIdentifierForOutputIndex(0), AstFactory.BuildNullNode()) };
            }
            var sliderValue = AstFactory.BuildDoubleNode(SliderValue);
            var functionCall =
              AstFactory.BuildFunctionCall(
                new Func<int, int, double, List<Rectangle>>(GridFunction.RectangularGrid),
                new List<AssociativeNode> { inputAstNodes[0], inputAstNodes[1], sliderValue });

            return new[] { AstFactory.BuildAssignment(GetAstIdentifierForOutputIndex(0), functionCall) };
        }
    }
}

이것은 Zero-Touch 노드와 다릅니다. 각 부분의 기능을 살펴보겠습니다.

노드 속성(예: 이름, 카테고리, InPort/OutPort 이름, InPort/OutPort 유형, 설명)을 지정합니다.
public class GridNodeModel : NodeModel은 Dynamo.Graph.Nodes에서 NodeModel 클래스를 상속하는 클래스입니다.
public GridNodeModel() { RegisterAllPorts(); }는 노드 입력 및 출력을 등록하는 생성자입니다.
BuildOutputAst()는 NodeModel 노드에서 데이터를 반환하는 데 필요한 구조인 AST(추상 구문 트리)를 반환합니다.
AstFactory.BuildFunctionCall()은 GridFunctions.cs에서 RectangularGrid 함수를 호출합니다.
new Func<int, int, double, List<Rectangle>>(GridFunction.RectangularGrid)는 함수와 해당 매개변수를 지정합니다.
new List<AssociativeNode> { inputAstNodes[0], inputAstNodes[1], sliderValue });는 노드 입력을 함수 매개변수에 매핑합니다.
AstFactory.BuildNullNode()는 입력 포트가 연결되지 않은 경우 null 노드를 빌드합니다. 이는 노드에 경고가 표시되지 않도록 하기 위한 것입니다.
RaisePropertyChanged("SliderValue")는 슬라이더 값이 변경되면 UI에 알립니다.
var sliderValue = AstFactory.BuildDoubleNode(SliderValue)는 AST에서 슬라이더 값을 나타내는 노드를 빌드합니다.
functionCall 변수 new List<AssociativeNode> { inputAstNodes[0], sliderValue });에서 sliderValue 변수에 대한 입력을 변경합니다.

3. 함수 호출

CustomNodeModelFunction 프로젝트는 CustomNodeModel과 별도의 어셈블리에 빌드되므로 호출할 수 있습니다.

다음 코드를 GridFunction.cs에 복사합니다.

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

namespace CustomNodeModel.CustomNodeModelFunction
{
    [IsVisibleInDynamoLibrary(false)]
    public class GridFunction
    {
        [IsVisibleInDynamoLibrary(false)]
        public static List<Rectangle> RectangularGrid(int xCount = 10, int yCount = 10, double rand = 1)
        {
            double x = 0;
            double y = 0;

            Point pt = null;
            Vector vec = null;
            Plane bP = null;

            Random rnd = new Random(2);

            var pList = new List<Rectangle>();
            for (int i = 0; i < xCount; i++)
            {
                y++;
                x = 0;
                for (int j = 0; j < yCount; j++)
                {
                    double rNum = rnd.NextDouble();
                    double scale = rNum * (1 - rand) + rand;
                    x++;
                    pt = Point.ByCoordinates(x, y);
                    vec = Vector.ZAxis();
                    bP = Plane.ByOriginNormal(pt, vec);
                    Rectangle rect = Rectangle.ByWidthLength(bP, scale, scale);
                    pList.Add(rect);
                }
            }
            pt.Dispose();
            vec.Dispose();
            bP.Dispose();
            return pList;
        }
    }
}

이 함수 클래스는 다음 한 가지 차이점을 제외하면 Zero-Touch 그리드 사례 연구와 매우 유사합니다.

함수가 이미 CustomNodeModel에서 호출되고 있으므로 [IsVisibleInDynamoLibrary(false)]는 Dynamo가 다음 메서드 및 클래스를 "인식"하지 못하도록 합니다.

NuGet 패키지에 대한 참조를 추가한 것처럼, 함수를 호출하려면 CustomNodeModel이 CustomNodeModelFunction을 참조해야 합니다.

CustomNodeModel에 대한 using 문은 함수를 참조할 때까지 비활성화됩니다.
CustomNodeModel을 마우스 오른쪽 버튼으로 클릭하고 Add > Reference를 선택합니다.
Projects > Solution을 선택합니다.
CustomNodeModelFunction을 확인합니다.
Ok를 클릭합니다.

4. 뷰 사용자 지정하기

슬라이더를 생성하려면 INodeViewCustomization 인터페이스를 구현하여 UI를 사용자 지정해야 합니다.

다음 코드를 GridNodeView.cs에 복사합니다.

using Dynamo.Controls;
using Dynamo.Wpf;

namespace CustomNodeModel.CustomNodeModel
{
    public class CustomNodeModelView : INodeViewCustomization<GridNodeModel>
    {
        public void CustomizeView(GridNodeModel model, NodeView nodeView)
        {
            var slider = new Slider();
            nodeView.inputGrid.Children.Add(slider);
            slider.DataContext = model;
        }

        public void Dispose()
        {
        }
    }
}

public class CustomNodeModelView : INodeViewCustomization<GridNodeModel>은 UI를 사용자 지정하는 데 필요한 함수를 정의합니다.

프로젝트 구조를 설정한 후 Visual Studio의 설계 환경을 사용하여 사용자 컨트롤을 빌드하고 해당 매개변수를 .xaml 파일에 정의합니다. 도구 상자에서 슬라이더를 <Grid>...</Grid>에 추가합니다.

CustomNodeModel을 마우스 오른쪽 버튼으로 클릭하고 Add > New Item을 선택합니다.
WPF를 선택합니다.
사용자 컨트롤의 이름을 Slider로 지정합니다.
Add를 클릭합니다.

다음 코드를 Slider.xaml에 복사합니다.

<UserControl x:Class="CustomNodeModel.CustomNodeModel.Slider"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
             xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
             xmlns:local="clr-namespace:CustomNodeModel.CustomNodeModel"
             mc:Ignorable="d" 
             d:DesignHeight="75" d:DesignWidth="100">
    <Grid Margin="10">
        <Slider Grid.Row="0" Width="80" Minimum="0" Maximum="1" IsSnapToTickEnabled="True" TickFrequency="0.01" Value="{Binding SliderValue}"/>
    </Grid>
</UserControl>

슬라이더 컨트롤의 매개변수는 .xaml 파일에 정의되어 있습니다. 최소 및 최대 속성은 이 슬라이더의 숫자 범위를 정의합니다.
<Grid>...</Grid> 안에 Visual Studio 도구 상자의 다양한 사용자 컨트롤을 배치할 수 있습니다.

Slider.xaml 파일을 생성했을 때, Visual Studio는 슬라이더를 초기화하는 Slider.xaml.cs라는 C# 파일을 자동으로 생성했습니다. 이 파일에서 네임스페이스를 변경합니다.

using System.Windows.Controls;

namespace CustomNodeModel.CustomNodeModel
{
    /// <summary>
    /// Interaction logic for Slider.xaml
    /// </summary>
    public partial class Slider : UserControl
    {
        public Slider()
        {
            InitializeComponent();
        }
    }
}

네임스페이스는 CustomNodeModel.CustomNodeModel이어야 합니다.

GridNodeModel.cs는 슬라이더 계산 논리를 정의합니다.

5 패키지로 구성하기

프로젝트를 빌드하기 전 마지막 단계는 Dynamo에서 패키지를 읽을 수 있도록 pkg.json 파일을 추가하는 것입니다.

CustomNodeModel을 마우스 오른쪽 버튼으로 클릭하고 Add > New Item을 선택합니다.
Web을 선택합니다.
JSON File을 선택합니다.
파일 이름을 pkg.json으로 지정합니다.
Add를 클릭합니다.

다음 코드를 pkg.json에 복사합니다.

{
  "license": "MIT",
  "file_hash": null,
  "name": "CustomNodeModel",
  "version": "1.0.0",
  "description": "Sample node",
  "group": "CustomNodes",
  "keywords": [ "grid", "random" ],
  "dependencies": [],
  "contents": "Sample node",
  "engine_version": "1.3.0",
  "engine": "dynamo",
  "engine_metadata": "",
  "site_url": "",
  "repository_url": "",
  "contains_binaries": true,
  "node_libraries": [
    "CustomNodeModel, Version=1.0.0, Culture=neutral, PublicKeyToken=null",
    "CustomNodeModelFunction, Version=1.0.0, Culture=neutral, PublicKeyToken=null"
  ]
}

"name":은 Dynamo 라이브러리에서 패키지 이름과 해당 그룹을 결정합니다.
"keywords":는 Dynamo 라이브러리 검색을 위한 검색 용어를 제공합니다.
"node_libraries": []는 패키지와 연관된 라이브러리입니다.
마지막 단계는 솔루션을 빌드하고 Dynamo 패키지로 게시하는 것입니다. 온라인에 게시하기 전에 로컬 패키지를 생성하는 방법과 Visual Studio에서 바로 패키지를 빌드하는 방법은 패키지 배포 장을 참조하십시오.

Dynamo 2.x용 패키지 및 Dynamo 라이브러리 업데이트하기

소개:

Dynamo 2.0은 주 릴리즈이며 일부 API가 변경되거나 제거되었습니다. 노드 및 패키지 작성자에게 영향을 미칠 수 있는 가장 큰 변경 사항 중 하나는 JSON 파일 형식으로의 전환입니다.

일반적으로 Zero Touch 노드 작성자는 2.0에서 패키지를 실행하기 위해 할 작업이 거의 없습니다.

NodeModel에서 직접 파생되는 노드와 UI 노드는 2.x에서 실행하는 데 더 많은 작업이 필요합니다.

확장 작성자는 확장에서 사용하는 Dynamo Core API의 양에 따라 몇 가지 변경 사항을 적용할 수도 있습니다.

일반 패키징 규칙:

Dynamo 또는 Dynamo Revit .dll을 패키지와 번들로 묶지 마십시오. 이러한 dll은 Dynamo에 의해 이미 로드됩니다. 사용자가 로드한 버전과 다른 버전을 번들로 묶으면 (예: Dynamo Core 1.3을 배포하는데 사용자가 Dynamo 2.0에서 패키지를 실행 중인 경우) 이상한 런타임 버그가 발생합니다. 여기에는 DynamoCore.dll, DynamoServices.dll, DSCodeNodes.dll, ProtoGeometry.dll 등의 dll이 포함됩니다.
가능하다면 newtonsoft.json.net을 패키지와 번들로 묶어서 배포하지 마십시오. 이 dll은 Dynamo 2.x에 의해서도 이미 로드됩니다. 위와 동일한 이슈가 발생할 수 있습니다.
가능하다면 CEFSharp을 패키지와 번들로 묶어서 배포하지 마십시오. 이 dll은 Dynamo 2.x에 의해서도 이미 로드됩니다. 위와 동일한 이슈가 발생할 수 있습니다.
일반적으로, 해당 종속성 버전을 제어해야 하는 경우 Dynamo 또는 Revit과 종속성을 공유하지 않도록 합니다.

일반적인 이슈:

1) 그래프를 열었을 때 일부 노드에 이름이 같은 포트가 여러 개 있었지만, 저장할 때는 그래프가 올바르게 표시되었습니다. 이 이슈는 몇 가지 원인으로 인해 발생할 수 있습니다.

일반적인 근본 원인은 노드를 만들 때 포트를 다시 만든 생성자를 사용했기 때문입니다. 그 대신 포트를 로드한 생성자를 사용했어야 합니다. 이러한 생성자는 일반적으로 [JsonConstructor]로 표시됩니다. 예제는 아래를 참조하십시오.

이 문제는 다음과 같은 이유로 발생할 수 있습니다.

일치하는 [JsonConstructor]가 없거나 JSON .dyn에서 Inports 및 Outports를 전달하지 않았습니다.
동일한 프로세스에 두 가지 버전의 JSON.net이 동시에 로드되어 .net 런타임 오류가 발생해 생성자를 표시하는 데 [JsonConstructor] 속성을 올바르게 사용할 수 없었습니다.
현재 Dynamo 버전과 다른 버전의 DynamoServices.dll이 패키지와 함께 번들로 묶여서 .net 런타임이 [MultiReturn] 속성을 식별하지 못해 다양한 속성으로 표시된 Zero-Touch 노드에 해당 속성이 적용되지 않습니다. 노드가 여러 포트가 아닌 하나의 사전 출력을 반환하는 것을 확인할 수 있습니다.

2) 그래프를 로드할 때 노드가 완전히 누락되어 콘솔에 몇 가지 오류가 표시됩니다.

이는 몇 가지 이유로 역직렬화에 실패한 경우 발생할 수 있습니다. 필요한 특성만 직렬화하는 것이 좋습니다. 로드하거나 저장할 필요가 없는 복잡한 특성에는 [JsonIgnore]를 사용하여 무시할 수 있습니다. 이러한 특성으로는 function pointer, delegate, action, 또는 event 등이 있습니다. 이러한 특성은 일반적으로 역직렬화에 실패하여 런타임 오류를 발생시키므로 직렬화해서는 안 됩니다.

심층적으로 업그레이드하기:

사용자 지정 노드 1.3 - > 2.0

libraries.js에서 사용자 지정 노드 구성하기

알려진 이슈:

사용자 지정 노드 이름과 카테고리 이름이 libraries.js에서 동일한 수준으로 일치하면 예기치 않은 동작이 발생합니다. QNTM-3653 - 카테고리 및 노드에 동일한 이름을 사용하지 마십시오.
주석은 선 주석 대신 블록 주석으로 변환됩니다.
짧은 유형의 이름이 전체 이름으로 바뀝니다. 예를 들어, 사용자 지정 노드를 다시 로드할 때 유형을 지정하지 않은 경우 기본 유형인 var[]..[]이 표시됩니다.

Zero Touch 노드 1.3 -> 2.0

Dynamo 2.0에서는 리스트와 사전 유형이 분리되었으며 리스트 및 사전을 생성하기 위한 구문이 변경되었습니다. 리스트는 []를 사용하여 초기화되고 사전은 {}를 사용합니다. 이전에 DefaultArgument 속성을 사용하여 Zero-Touch 노드에 매개변수를 표시하고 리스트 구문을 사용하여 someFunc([DefaultArgument("{0,1,2}")])와 같은 특정 리스트를 기본값으로 설정했다면, 이는 더 이상 유효하지 않으며 리스트에 대한 새 초기화 구문을 사용하도록 DesignScript 조각을 수정해야 합니다.
위에 설명한 것처럼 Dynamo dll을 패키지와 함께 배포하지 마십시오(DynamoCore, DynamoServices 등).

Node Model 노드 1.3 -> 2.0

Dynamo 2.x로 업데이트할 때 가장 많은 작업을 수행해야 하는 노드는 Node Model 노드입니다. 상위 수준에서는 노드 유형의 새 인스턴스를 인스턴스화하는 데 사용되는 일반 nodeModel 생성자 외에 json에서 노드를 로드하는 데만 사용되는 생성자를 구현해야 합니다. 이러한 값을 구분하려면 로드 시간 생성자에 newtonsoft.Json.net의 속성인 [JsonConstructor]를 표시합니다.

생성자의 매개변수 이름은 일반적으로 JSON 특성의 이름과 일치해야 하지만, [JsonProperty] 속성을 사용하여 직렬화된 이름을 재정의하는 경우 매핑이 더 복잡해집니다. 자세한 내용은 Json.net 문서를 참조하십시오.

JSON 생성자

NodeModel 기준 클래스(또는 기타 Dynamo 코어 기준 클래스, 예: DSDropDownBase)에서 파생된 노드를 업데이트하는 데 필요한 가장 일반적인 변경 사항은 클래스에 JSON 생성자를 추가해야 한다는 것입니다.

매개변수가 없는 원래 생성자는 여전히 Dynamo 내에서 생성된 새 노드의 초기화를 처리합니다(예: 라이브러리를 통해). JSON 생성자는 저장된 .dyn 또는 .dyf 파일에서 역직렬화된(로드된) 노드를 초기화하는 데 필요합니다.

JSON 생성자는 JSON 로드 논리에서 제공하는 inPorts 및 outPorts에 대한 PortModel 매개변수가 있다는 점에서 기본 생성자와 다릅니다. 노드에 대한 포트 등록을 위한 호출은 데이터가 .dyn 파일에 존재하므로 여기서는 필요하지 않습니다. JSON 생성자의 예는 다음과 같습니다.

using Newtonsoft.Json; //New dependency for Json

………

[JsonConstructor] //Attribute required to identity the Json constructor

//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에서 읽을 수 있으므로 이 생성자에서 반복할 필요가 없습니다.

이것이 nodeModels에 대한 JSON 생성자와 비JSON 생성자 간의 주요 차이점입니다. JSON 생성자는 파일에서 로드될 때 호출되며 로드된 데이터를 전달받습니다. 그러나 다른 사용자 로직은 JSON 생성자에서 복제되어야 합니다 (예: 노드에 대한 이벤트 핸들러 초기화 또는 연결).

예제는 DynamoSamples 리포지토리 -> ButtonCustomNodeModel, DropDown 또는 SliderCustomNodeModel 에서 확인할 수 있습니다

공용 특성 및 직렬화

이전에는 개발자가 SerializeCore 및 DeserializeCore 메서드를 통해 특정 모델 데이터를 xml 문서로 직렬화하고 역직렬화할 수 있었습니다. 이러한 메서드는 API에 여전히 존재하지만 Dynamo의 향후 릴리즈에서는 더 이상 사용되지 않습니다(예는 여기 에서 확인할 수 있음). 이제 JSON.NET 구현을 통해 NodeModel 파생 클래스의 public 특성을 .dyn 파일에 직접 직렬화할 수 있습니다. JSON.Net은 특성이 직렬화되는 방식을 제어하는 여러 속성을 제공합니다.

PropertyName을 지정하는 이 예는 Dynamo 리포지토리의 여기에서 확인할 수 있습니다.

[JsonProperty(PropertyName = "InputValue")]

public DSColor DsColor {...

변환기:

참고 자체 JSON.net 변환기 클래스를 만드는 경우 Dynamo에는 현재 로드 및 저장 메서드에 이 클래스를 주입할 수 있는 메커니즘이 없습니다. 따라서 클래스에 [JsonConverter] 속성을 표시하더라도 사용할 수 없습니다. 대신 setter 또는 getter에서 직접 변환기를 호출할 수 있습니다. //TODO 이 제한에 대한 확인이 필요합니다. 어떤 증거라도 환영합니다.

특성을 문자열로 변환하기 위한 직렬화 메서드를 지정하는 예사는 Dynamo 리포지토리의 여기에서 확인할 수 있습니다.

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

public ConversionMetricUnit SelectedMetricConversion{...

특성 무시하기

직렬화용이 아닌 public 특성에는 [JsonIgnore] 속성을 추가해야 합니다. 노드가 .dyn 파일에 저장되면 이 데이터가 직렬화 메커니즘에서 무시되어 그래프를 다시 열 때 예상치 못한 결과가 발생하지 않습니다. 이에 대한 예는 Dynamo 리포지토리의 여기에서 확인할 수 있습니다.

실행 취소/다시 실행

위에서 설명한 대로, 과거에는 노드를 xml .dyn 파일에 저장하고 로드하는 데 SerializeCore 및 DeserializeCore 메서드를 사용했습니다. 또한 실행 취소/다시 실행을 위해 노드 상태를 저장 및 로드하는 데 사용되었으며 지금도 여전히 사용되고 있습니다! nodeModel UI 노드에 대해 복잡한 실행 취소/다시 실행 기능을 구현하려면 이러한 메서드를 구현하고 이러한 메서드에 매개변수로 제공된 XML 문서 객체로 직렬화해야 합니다. UI 노드가 복잡할 때를 제외하고는 드물게 사용될 것입니다.

입력 및 출력 포트 API

2.0 API 변경 사항의 영향을 받는 nodeModel 노드에서 흔히 발생하는 한 가지 문제는 노드 생성자에서 포트를 등록하는 것과 관련이 있습니다. Dynamo 또는 DynamoSamples 리포지토리의 예제를 보면 이전에 InPortData.Add() 또는 OutPortData.Add() 메서드를 사용했다는 것을 확인할 수 있습니다. 이전에는 Dynamo API에서 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

InPorts.Add(new PortModel(PortType.Input, this, new PortData("Port Name", "Port Description"))); //Recommended 2.0

변환된 코드의 예제는 Dynamo 리포지토리 -> DynamoConvert.cs 또는 FileSystem.cs에서 확인할 수 있습니다.

2.0 API 변경 사항의 영향을 받는 다른 일반적인 사용 사례는 포트 커넥터의 유무에 따라 노드 동작을 결정하는 BuildAst() 메서드에서 일반적으로 사용하는 메서드와 관련이 있습니다. 이전에는 연결된 포트 상태의 유효성을 검사하는 데 HasConnectedInput(index)가 사용되었습니다. 이제 개발자는 InPorts[0].IsConnected 특성을 사용하여 포트 연결 상태를 확인해야 합니다. 이 아이콘의 예는 Dynamo 리포지토리의 ColorRange.cs에서 확인할 수 있습니다.

예제:

1.3 UI 노드를 Dynamo 2.x로 업그레이드하는 과정을 살펴보겠습니다.

using System;
using System.Collections.Generic;
using Dynamo.Graph.Nodes;
using CustomNodeModel.CustomNodeModelFunction;
using ProtoCore.AST.AssociativeAST;
using Autodesk.DesignScript.Geometry;

namespace CustomNodeModel.CustomNodeModel
{
    [NodeName("RectangularGrid")]
    [NodeDescription("An example NodeModel node that creates a rectangular grid. The slider randomly scales the cells.")]
    [NodeCategory("CustomNodeModel")]
    [InPortNames("xCount", "yCount")]
    [InPortTypes("double", "double")]
    [InPortDescriptions("Number of cells in the X direction", "Number of cells in the Y direction")]
    [OutPortNames("Rectangles")]
    [OutPortTypes("Autodesk.DesignScript.Geometry.Rectangle[]")]
    [OutPortDescriptions("A list of rectangles")]
    [IsDesignScriptCompatible]
    public class GridNodeModel : NodeModel
    {
        private double _sliderValue;
        public double SliderValue
        {
            get { return _sliderValue; }
            set
            {
                _sliderValue = value;
                RaisePropertyChanged("SliderValue");
                OnNodeModified(false);
            }
        }
        public GridNodeModel()
        {
            RegisterAllPorts();
        }
        public override IEnumerable<AssociativeNode> BuildOutputAst(List<AssociativeNode> inputAstNodes)
        {
            if (!HasConnectedInput(0) || !HasConnectedInput(1))
            {
                return new[] { AstFactory.BuildAssignment(GetAstIdentifierForOutputIndex(0), AstFactory.BuildNullNode()) };
            }
            var sliderValue = AstFactory.BuildDoubleNode(SliderValue);
            var functionCall =
              AstFactory.BuildFunctionCall(
                new Func<int, int, double, List<Rectangle>>(GridFunction.RectangularGrid),
                new List<AssociativeNode> { inputAstNodes[0], inputAstNodes[1], sliderValue });

            return new[] { AstFactory.BuildAssignment(GetAstIdentifierForOutputIndex(0), functionCall) };
        }
    }
}

이 nodeModel 클래스가 2.0에서 올바르게 로드 및 저장되도록 하려면 포트 로드를 처리하는 jsonConstructor를 추가하기만 하면 됩니다. 기본 생성자에 포트를 전달하기만 하면 이 구현은 비어 있습니다.

[JsonConstructor]
protected GridNodeModel(IEnumerable<PortModel> Inports, IEnumerable<PortModel> Outports ) :
base(Inports,Outports)
{

}

참고: RegisterPorts()는 노드 클래스의 입력 및 출력 매개변수 속성을 사용하여 새 포트를 생성하므로 JsonConstructor에서 이를 호출하거나 이에 대한 변형을 호출하지 마십시오 우리는 생성자에게 전달되는 로드된 포트를 사용하려고 하므로 호출해서는 안 됩니다.

[InPortNames("xCount", "yCount")]
[InPortTypes("double", "double")]

이 예에서는 가능한 최소한의 로드 JSON 생성자를 추가합니다. 하지만 생성자 내부에 이벤트 처리를 위한 수신기를 설정하는 등 좀 더 복잡한 구성 논리를 수행해야 한다면 어떻게 해야 할까요? DynamoSamples 리포지토리에서 가져온 다음 샘플은 이 문서의 JsonConstructors Section 위쪽에 링크되어 있습니다.

다음은 UI 노드에 대한 보다 복잡한 생성자입니다.

 public ButtonCustomNodeModel()
        {
            // When you create a UI node, you need to do the
            // work of setting up the ports yourself. To do this,
            // you can populate the InPorts and the OutPorts
            // collections with PortData objects describing your ports.
            InPorts.Add(new PortModel(PortType.Input, this, new PortData("inputString", "a string value displayed on our button")));

            // Nodes can have an arbitrary number of inputs and outputs.
            // If you want more ports, just create more PortData objects.
            OutPorts.Add(new PortModel(PortType.Output, this, new PortData("button value", "returns the string value displayed on our button")));
            OutPorts.Add(new PortModel(PortType.Output, this, new PortData("window value", "returns the string value displayed in our window when button is pressed")));

            // This call is required to ensure that your ports are
            // properly created.
            RegisterAllPorts();

            // Listen for input port disconnection to trigger button UI update
            this.PortDisconnected += ButtonCustomNodeModel_PortDisconnected;

            // The arugment lacing is the way in which Dynamo handles
            // inputs of lists. If you don't want your node to
            // support argument lacing, you can set this to LacingStrategy.Disabled.
            ArgumentLacing = LacingStrategy.Disabled;

            // We create a DelegateCommand object which will be 
            // bound to our button in our custom UI. Clicking the button 
            // will call the ShowMessage method.
            ButtonCommand = new DelegateCommand(ShowMessage, CanShowMessage);

            // Setting our property here will trigger a 
            // property change notification and the UI 
            // will be updated to reflect the new value.
            ButtonText = defaultButtonText;
            WindowText = defaultWindowText;
        }

파일에서 이 노드를 로드하기 위한 JSON 생성자를 추가할 때 이 논리 중 일부를 다시 생성해야 합니다. 이때, 포트를 생성하거나 레이싱을 설정하거나 파일에서 로드할 수 있는 특성의 기본값을 설정하는 코드는 포함하지 않습니다.

        // This constructor is called when opening a Json graph.

        [JsonConstructor]
        ButtonCustomNodeModel(IEnumerable<PortModel> inPorts, IEnumerable<PortModel> outPorts) : base(inPorts, outPorts)
        {
            this.PortDisconnected += ButtonCustomNodeModel_PortDisconnected;
            ButtonCommand = new DelegateCommand(ShowMessage, CanShowMessage);
        }

ButtonText 및 WindowText와 같은 JSON에 직렬화된 다른 공용 특성은 생성자에 명시적 매개변수로 추가되지 않으며, 이러한 특성의 setter를 사용하여 JSON.net에서 자동으로 설정됩니다.

Dynamo 3.x용 패키지 및 Dynamo 라이브러리 업데이트하기

소개

이 섹션에는 그래프, 패키지 및 라이브러리를 Dynamo 3.x로 마이그레이션할 때 발생할 수 있는 문제에 대한 정보가 포함되어 있습니다.

Dynamo 3.0은 주 릴리즈이며 일부 API는 변경되거나 제거되었습니다. Dynamo 3.x의 개발자 또는 사용자가 영향을 받을 가능성이 높은 가장 큰 변화는 .NET8으로의 전환입니다.

.NET은 Dynamo 작성에 사용된 C# 언어의 기반이 되는 런타임입니다. Dynamo는 나머지 Autodesk 에코시스템과 더불어 이 런타임의 최신 버전으로 업데이트되었습니다.

에서 자세한 내용을 확인할 수 있습니다.

패키지 호환성

Dynamo 3.x에서 Dynamo 2.x 패키지 사용

Dynamo 3.x는 이제 .NET8 런타임에서 실행되기 때문에 Dynamo 3.x에서 Dynamo 2.x (.NET48 사용) 용으로 작성된 패키지의 작동이 보장되지 않습니다. Dynamo 3.0 미만 버전에서 게시된 패키지를 Dynamo 3.x에서 다운로드하려고 하면 해당 패키지가 이전 버전의 Dynamo에서 제공되었다는 경고가 표시됩니다.

이것은 패키지가 작동하지 않는다는 의미가 아닙니다 단순히 호환성 문제가 발생할 수 있다는 경고이며, 일반적으로 특별히 Dynamo 3.x용으로 작성된 최신 버전이 있는지 확인하는 것이 좋습니다.

패키지 로드 시 Dynamo 로그 파일에 이러한 유형의 경고가 표시될 수도 있습니다. 모든 것이 제대로 작동하는 경우 이 경고를 무시하면 됩니다.

Dynamo 2.x에서 Dynamo 3.x 패키지 사용

Dynamo 3.x (.Net8 사용) 용으로 작성된 패키지가 Dynamo 2.x에서 작동할 가능성은 거의 없습니다. 또한 이전 버전을 사용하는 동안 최신 버전 Dynamo용으로 작성된 패키지를 다운로드할 때 경고가 표시됩니다.

확장

확장은 Dynamo 에코시스템의 강력한 개발 도구입니다. 개발자는 이러한 확장을 통해 Dynamo 상호 작용 및 논리를 기반으로 사용자 지정 기능을 구동할 수 있습니다. 확장은 두 가지 주요 카테고리, 즉 확장과 뷰 확장으로 나눌 수 있습니다. 이름에서 알 수 있듯이, 뷰 확장 프레임워크를 사용하면 사용자 지정 메뉴 항목을 등록하여 Dynamo UI를 확장할 수 있습니다. 일반 확장은 UI를 제외하면 매우 유사한 방식으로 작동합니다. 예를 들어, Dynamo 콘솔에 특정 정보를 기록하는 확장을 빌드할 수 있습니다. 이 시나리오에서는 사용자 지정 UI가 필요하지 않으므로 확장을 사용하여 수행할 수도 있습니다.

확장 사례 연구

DynamoSamples Github 리포지토리의 SampleViewExtension 예제에 따라 그래프에 활성 노드를 실시간으로 표시하는 간단한 모델리스 창을 생성하는 데 필요한 단계를 살펴보겠습니다. 뷰 확장을 사용하려면 창에 대한 UI를 생성하고 뷰 모델에 값을 바인딩해야 합니다.

뷰 확장 창은 Github 리포지토리의 SampleViewExtension 예제를 따라 개발되었습니다.

예제를 처음부터 빌드할 예정이지만, 참조하기 위해 DynamoSamples 리포지토리를 다운로드하고 빌드할 수도 있습니다.

DynamoSamples 리포지토리: https://github.com/DynamoDS/DynamoSamples

이 연습에서는 DynamoSamples/src/에 있는 SampleViewExtension이라는 프로젝트를 참조합니다.

뷰 확장을 구현하는 방법

뷰 확장에는 다음과 같은 세 가지 필수적인 부분이 있습니다.

뷰 모델을 생성하는 클래스와 IViewExtension을 구현하는 클래스가 포함된 어셈블리
런타임 시 이 어셈블리를 찾아야 하는 위치와 확장의 유형을 Dynamo에 알려주는 .xml 파일
그래픽 화면표시에 데이터를 바인딩하고 창의 모양을 결정하는 .xaml 파일

1. 프로젝트 구조 생성하기

먼저 이름이 SampleViewExtension인 새 Class Library 프로젝트를 생성합니다.

File > New > Project를 선택하여 새 프로젝트를 생성합니다.
Class Library를 선택합니다.
프로젝트의 이름을 SampleViewExtension으로 지정합니다.
Ok를 선택합니다.

이 프로젝트에는 두 개의 클래스가 필요합니다. 한 클래스는 IViewExtension을 구현하고, 다른 클래스는 NotificationObject.을 구현합니다. IViewExtension은 확장이 배포, 로드, 참조 및 삭제되는 방식에 대한 모든 정보를 포함하고 있습니다. NotificationObject는 Dynamo 및 IDisposable의 변경 사항에 대한 알림을 제공합니다. 변경이 이루어지면 그에 따라 개수가 업데이트됩니다.

IViewExtension을 구현할 SampleViewExtension.cs라는 이름의 클래스 파일
NotificationObject를 구현할 SampleWindowViewMode.cs라는 이름의 클래스 파일

IViewExtension을 사용하려면 WpfUILibrary NuGet 패키지가 필요합니다. 이 패키지를 설치하면 Core, Services 및 ZeroTouchLibrary 패키지가 자동으로 설치됩니다.

WpfUILibrary를 선택합니다.
Install을 선택하여 모든 종속 패키지를 설치합니다.

2. IViewExtension 클래스 구현하기

IViewExtension 클래스에서 Dynamo를 시작할 때, 확장이 로드될 때, Dynamo가 종료될 때 수행되는 작업을 결정해 보겠습니다. SampleViewExtension.cs 클래스 파일에서 다음 코드를 추가합니다.

using System;
using System.Windows;
using System.Windows.Controls;
using Dynamo.Wpf.Extensions;

namespace SampleViewExtension
{

    public class SampleViewExtension : IViewExtension
    {
        private MenuItem sampleMenuItem;

        public void Dispose()
        {
        }

        public void Startup(ViewStartupParams p)
        {
        }

        public void Loaded(ViewLoadedParams p)
        {
            // Save a reference to your loaded parameters.
            // You'll need these later when you want to use
            // the supplied workspaces

            sampleMenuItem = new MenuItem {Header = "Show View Extension Sample Window"};
            sampleMenuItem.Click += (sender, args) =>
            {
                var viewModel = new SampleWindowViewModel(p);
                var window = new SampleWindow
                {
                    // Set the data context for the main grid in the window.
                    MainGrid = { DataContext = viewModel },

                    // Set the owner of the window to the Dynamo window.
                    Owner = p.DynamoWindow
                };

                window.Left = window.Owner.Left + 400;
                window.Top = window.Owner.Top + 200;

                // Show a modeless window.
                window.Show();
            };
            p.AddMenuItem(MenuBarType.View, sampleMenuItem);
        }

        public void Shutdown()
        {
        }

        public string UniqueId
        {
            get
            {
                return Guid.NewGuid().ToString();
            }  
        } 

        public string Name
        {
            get
            {
                return "Sample View Extension";
            }
        } 

    }
}

SampleViewExtension 클래스는 클릭 가능한 메뉴 항목을 생성하여 창을 열고 뷰 모델 및 창에 연결합니다.

public class SampleViewExtension : IViewExtension SampleViewExtension은 IViewExtension 인터페이스에서 상속되어 메뉴 항목을 생성하는 데 필요한 모든 것을 제공합니다.
sampleMenuItem = new MenuItem { Header = "Show View Extension Sample Window" };는 메뉴 항목을 생성하여 View 메뉴에 추가합니다.

메뉴 항목

sampleMenuItem.Click += (sender, args)는 메뉴 항목을 클릭할 때 새 창을 여는 이벤트를 트리거합니다.
MainGrid = { DataContext = viewModel }은 창에서 주 그리드에 대한 데이터 컨텍스트를 설정하며, 생성하려고 하는 .xaml 파일에서 Main Grid를 참조합니다.
Owner = p.DynamoWindow는 팝업 창의 소유자를 Dynamo로 설정합니다. 즉, 새 창이 Dynamo에 종속되므로 Dynamo 최소화, 최대화 및 복원과 같은 작업을 수행하면 새 창이 이와 동일한 동작을 따르게 됩니다.
window.Show();는 추가 창 특성이 설정된 창을 표시합니다.

3. 뷰 모델 구현하기

지금까지 창의 기본 매개변수 몇 가지를 설정했으므로, 이제 다양한 Dynamo 관련 이벤트에 응답하기 위한 논리를 추가하고 이러한 이벤트에 따라 UI가 업데이트되도록 하겠습니다. 다음 코드를 SampleWindowViewModel.cs 클래스 파일에 복사합니다.

using System;
using Dynamo.Core;
using Dynamo.Extensions;
using Dynamo.Graph.Nodes;

namespace SampleViewExtension
{
    public class SampleWindowViewModel : NotificationObject, IDisposable
    {
        private string activeNodeTypes;
        private ReadyParams readyParams;

        // Displays active nodes in the workspace
        public string ActiveNodeTypes
        {
            get
            {
                activeNodeTypes = getNodeTypes();
                return activeNodeTypes;
            }
        }

        // Helper function that builds string of active nodes
        public string getNodeTypes()
        {
            string output = "Active nodes:\n";

            foreach (NodeModel node in readyParams.CurrentWorkspaceModel.Nodes)
            {
                string nickName = node.Name;
                output += nickName + "\n";
            }

            return output;
        }

        public SampleWindowViewModel(ReadyParams p)
        {
            readyParams = p;
            p.CurrentWorkspaceModel.NodeAdded += CurrentWorkspaceModel_NodesChanged;
            p.CurrentWorkspaceModel.NodeRemoved += CurrentWorkspaceModel_NodesChanged;
        }

        private void CurrentWorkspaceModel_NodesChanged(NodeModel obj)
        {
            RaisePropertyChanged("ActiveNodeTypes");
        }

        public void Dispose()
        {
            readyParams.CurrentWorkspaceModel.NodeAdded -= CurrentWorkspaceModel_NodesChanged;
            readyParams.CurrentWorkspaceModel.NodeRemoved -= CurrentWorkspaceModel_NodesChanged;
        }
    }
}

이 뷰 모델 클래스 구현은 CurrentWorkspaceModel을 수신하고 작업공간에서 노드가 추가되거나 제거될 때 이벤트를 트리거합니다. 이렇게 하면 데이터가 변경되어 업데이트가 필요하다는 것을 UI 또는 바인딩된 요소에 알리는 특성 변경이 발생합니다. 내부적으로 추가 도우미 함수 getNodeTypes()를 호출하는 ActiveNodeTypes getter가 호출됩니다. 이 함수는 캔버스의 모든 활성 노드를 반복하고, 이러한 노드의 이름이 포함된 문자열을 채우고, 이 문자열을 팝업 창에 표시할 .xaml 파일의 바인딩으로 반환합니다.

확장의 핵심 논리가 정의되었으므로, 이제 .xaml 파일을 사용하여 창의 모양 세부 사항을 지정하겠습니다. TextBlock Text에서 ActiveNodeTypes 특성 바인딩을 통해 문자열을 표시하는 간단한 창만 있으면 됩니다.

프로젝트를 마우스 오른쪽 버튼으로 클릭하고 Add > New Item...을 선택합니다.
창을 생성하기 위해 변경할 사용자 컨트롤 템플릿을 선택합니다.
새 파일의 이름을 SampleWindow.xaml로 지정합니다.
Add를 선택합니다.

창 .xaml 코드에서 SelectedNodesText를 텍스트 블록에 바인딩해야 합니다. 다음 코드를 SampleWindow.xaml에 추가합니다.

<Window x:Class="SampleViewExtension.SampleWindow"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
             xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
             xmlns:local="clr-namespace:SampleViewExtension"
             mc:Ignorable="d" 
             d:DesignHeight="300" d:DesignWidth="300"
            Width="500" Height="100">
    <Grid Name="MainGrid" 
          HorizontalAlignment="Stretch"
          VerticalAlignment="Stretch">
        <TextBlock HorizontalAlignment="Stretch" Text="{Binding ActiveNodeTypes}" FontFamily="Arial" Padding="10" FontWeight="Medium" FontSize="18" Background="#2d2d2d" Foreground="White"/>
    </Grid>
</Window>

Text="{Binding ActiveNodeTypes}"는 SampleWindowViewModel.cs에서 ActiveNodeTypes의 특성 값을 창의 TextBlock Text 값에 바인딩합니다.

이제 .xaml C# 백킹 파일 SampleWindow.xaml.cs에서 샘플 창을 초기화하겠습니다. 다음 코드를 SampleWindow.xaml에 추가합니다.

using System.Windows;

namespace SampleViewExtension
{
    /// <summary>
    /// Interaction logic for SampleWindow.xaml
    /// </summary>
    public partial class SampleWindow : Window
    {
        public SampleWindow()
        {
            InitializeComponent();
        }
    }
}

이제 뷰 확장을 빌드하고 Dynamo에 추가할 준비가 되었습니다. Dynamo에서 출력 .dll을 확장으로 등록하려면 xml 파일이 필요합니다.

프로젝트를 마우스 오른쪽 버튼으로 클릭하고 Add > New Item...을 선택합니다.
XML 파일을 선택합니다.
파일 이름을 SampleViewExtension_ViewExtensionDefinition.xml로 지정합니다.
Add를 선택합니다.

파일 이름은 "extensionName"_ViewExtensionDefinition.xml과 같이 확장 어셈블리를 참조하기 위해 Dynamo 표준을 따릅니다.

xml 파일에서 다음 코드를 추가하여 Dynamo에 확장 어셈블리를 찾을 위치를 알려줍니다.

<ViewExtensionDefinition>
  <AssemblyPath>C:\Users\username\Documents\Visual Studio 2015\Projects\SampleViewExtension\SampleViewExtension\bin\Debug\SampleViewExtension.dll</AssemblyPath>
  <TypeName>SampleViewExtension.SampleViewExtension</TypeName>
</ViewExtensionDefinition>

이 예제에서는 기본 Visual Studio 프로젝트 폴더에 어셈블리를 빌드했습니다. <AssemblyPath>...</AssemblyPath> 대상을 어셈블리의 위치로 바꿉니다.

마지막 단계는 SampleViewExtension_ViewExtensionDefinition.xml 파일을 Dynamo Core 설치 디렉토리 C:\Program Files\Dynamo\Dynamo Core\1.3\viewExtensions에 있는 Dynamo의 뷰 확장 폴더에 복사하는 것입니다. extensions 및 viewExtensions를 위한 별도의 폴더가 있습니다. xml 파일을 잘못된 폴더에 배치하면 런타임 시 제대로 로드되지 않을 수 있습니다.

Dynamo의 뷰 확장 폴더에 복사한 .xml 파일

여기에는 뷰 확장에 대한 기본적인 소개만 나와 있습니다. 보다 정교한 사례 연구는 Github의 오픈 소스 프로젝트인 DynaShape 패키지를 참조하십시오. 이 패키지는 Dynamo 모델 뷰에서 실시간으로 편집할 수 있는 뷰 확장을 사용합니다.

DynaShape용 패키지 설치 프로그램은 Dynamo 포럼(https://forum.dynamobim.com/t/dynashape-published/11666)에서 다운로드할 수 있습니다.

소스 코드는 Github(https://github.com/LongNguyenP/DynaShape)에서 복제할 수 있습니다.

패키지 게시하기

패키지는 노드를 저장하고 Dynamo 커뮤니티와 공유할 수 있는 편리한 방법입니다. 패키지에는 Dynamo 작업공간에서 생성된 사용자 지정 노드부터 NodeModel 파생 노드까지 모든 것이 포함될 수 있습니다. 패키지는 패키지 관리자를 사용하여 게시되고 설치됩니다. 이 페이지 외에도 에 패키지에 대한 일반적인 설명이 나와 있습니다.

패키지 관리자란 무엇입니까?

Dynamo 패키지 관리자는 Dynamo 또는 웹 브라우저에서 액세스할 수 있는 소프트웨어 레지스트리(npm과 유사)입니다. 패키지 관리자에서는 패키지 설치, 게시, 업데이트 및 보기를 수행할 수 있습니다. 패키지 관리자는 npm과 마찬가지로 다양한 버전의 패키지를 유지합니다. 또한 프로젝트의 종속성을 관리하는 데도 도움이 됩니다.

브라우저에서 패키지를 검색하고 통계를 확인하십시오().

Dynamo의 패키지 관리자에서는 패키지 설치, 게시 및 업데이트를 수행할 수 있습니다.

온라인으로 패키지 검색: Packages > Search for a Package...
설치된 패키지 보기/편집: Packages > Manage Packages...
새 패키지 게시: Packages > Publish New Package...

패키지 게시하기

패키지는 Dynamo 내의 패키지 관리자를 통해 게시됩니다. 권장되는 프로세스는 로컬에 게시하고, 패키지를 테스트한 다음 온라인에 게시하여 커뮤니티와 공유하는 것입니다. NodeModel 사례 연구를 참조하여 RectangularGrid 노드를 로컬에 패키지로 게시한 다음 온라인에 게시하는 데 필요한 단계를 수행합니다.

Dynamo를 시작하고 Packages > Publish New Package...를 선택하여 Publish a Package 창을 엽니다.

Add file...을 선택하여 패키지에 추가할 파일을 찾습니다.
NodeModel 사례 연구에서 두 개의 .dll 파일을 선택합니다.
Ok를 선택합니다.

패키지 콘텐츠에 파일을 추가한 상태에서 패키지에 이름, 설명 및 버전을 지정합니다. Dynamo를 사용하여 패키지를 게시하면 pkg.json 파일이 자동으로 생성됩니다.

게시할 준비가 된 패키지가 있습니다.
이름, 설명 및 버전과 관련하여 필요한 정보를 입력합니다.
"로컬로 게시"를 클릭하여 게시하고 Dynamo의 패키지 폴더(AppData\Roaming\Dynamo\Dynamo Core\1.3\packages)를 선택하여 노드를 코어에서 사용할 수 있도록 합니다. 패키지를 공유할 준비가 될 때까지 항상 로컬에 게시합니다.

패키지를 게시하면 Dynamo 라이브러리의 CustomNodeModel 카테고리 아래에서 노드를 사용할 수 있습니다.

Dynamo 라이브러리에서 방금 생성한 패키지

패키지를 온라인에 게시할 준비가 되면 패키지 관리자를 열고 Publish를 선택한 다음 Publish Online을 선택합니다.

Dynamo가 패키지를 어떻게 포맷했는지 확인하려면 "CustomNodeModel" 오른쪽에 있는 세 개의 세로 점을 클릭하고 "루트 디렉토리 표시"를 선택합니다.
"Dynamo 패키지 게시" 창에서 Publish를 선택한 다음 Publish Online을 선택합니다.
패키지를 삭제하려면 Delete를 선택합니다.

패키지를 업데이트하려면 어떻게 해야 합니까?

패키지 업데이트는 게시하는 것과 프로세스가 유사합니다. 패키지 관리자를 열고 업데이트해야 하는 패키지에 대해 Publish Version...을 선택한 후 상위 버전을 입력합니다.

Publish Version을 선택하여 루트 디렉토리의 새 파일로 기존 패키지를 업데이트한 다음 로컬에 게시할지 아니면 온라인에 게시할지 선택합니다.

패키지 관리자 웹 클라이언트

패키지 관리자 웹 클라이언트는 버전 관리 및 다운로드 통계와 같은 패키지 데이터를 검색하고 보는 용도로만 사용됩니다.

Visual Studio에서 패키지 빌드하기

Dynamo용 패키지로 게시할 어셈블리를 개발하는 경우 필요한 모든 자산을 그룹화하여 패키지와 호환되는 디렉토리 구조에 배치하도록 프로젝트를 구성할 수 있습니다. 이렇게 하면 프로젝트를 패키지로 빠르게 테스트하고 사용자의 경험을 시뮬레이션할 수 있습니다.

패키지 폴더에 직접 빌드하는 방법

Visual Studio에서 패키지를 빌드하는 방법에는 두 가지가 있습니다.

xcopy 또는 Python 스크립트를 사용하는 프로젝트 설정 대화상자를 통해 빌드 후 이벤트를 추가하여 필요한 파일을 복사합니다.
.csproj 파일에서 "AfterBuild" 빌드 대상을 사용하여 파일 및 디렉토리 복사 작업을 생성합니다.

"AfterBuild"는 빌드 컴퓨터에서 사용할 수 없는 파일 복사에 의존하지 않으므로 이러한 유형의 작업(및 이 안내서에서 다루는 작업)에 선호되는 방법입니다.

AfterBuild 방법을 사용하여 패키지 파일 복사하기

소스 파일이 패키지 파일과 분리되도록 리포지토리의 디렉토리 구조를 설정합니다. CustomNodeModel 사례 연구를 사용하여 Visual Studio 프로젝트 및 연관된 모든 파일을 새 src 폴더에 배치합니다. 프로젝트에서 생성된 모든 패키지를 이 폴더에 저장할 예정입니다. 그러면 폴더 구조는 다음과 같게 됩니다.

프로젝트 파일을 새 src 폴더로 이동합니다.

대상이 CustomNodeModel.csproj 파일(다른 프로젝트 파일 아님)에 추가되었고 프로젝트에 기존 빌드 후 설정이 없는지 확인해야 합니다.
끝 </Project> 태그 앞에 AfterBuild 대상을 넣습니다.

<ItemGroup> 섹션에는 특정 파일 유형을 나타내는 여러 변수가 정의되어 있습니다. 예를 들어, Dll 변수는 확장자가 .dll인 출력 디렉토리의 모든 파일을 나타냅니다.

Copy 작업은 모든 .dll 파일을 디렉토리, 특히 빌드 중인 패키지 폴더에 복사하는 것입니다.

Dynamo 패키지에는 일반적으로 Dynamo 사용자 지정 노드 및 이미지와 같은 기타 자산을 위한 dyf 및 extra 폴더가 있습니다. 이러한 폴더를 생성하려면 MakeDir 작업을 사용해야 합니다. 이 작업은 폴더가 없는 경우 폴더를 생성합니다. 이 폴더에 파일을 수동으로 추가할 수 있습니다.

프로젝트를 빌드하면 이제 프로젝트 폴더에 이전에 생성한 src 폴더와 나란히 packages 폴더가 생성됩니다. packages 디렉토리 내에는 패키지에 필요한 모든 항목이 포함된 폴더가 있습니다. 또한 pkg.json 파일을 패키지 폴더에 복사하여 Dynamo가 패키지를 로드하도록 해야 합니다.

AfterBuild 대상이 생성한 새 패키지 폴더
프로젝트가 있는 기존 src 폴더
AfterBuild 대상에서 생성된 dyf 및 extra 폴더
pkg.json 파일을 수동으로 복사합니다.

이제 Dynamo의 패키지 관리자를 사용하여 패키지를 게시하거나 Dynamo의 패키지 디렉토리(<user>\AppData\Roaming\Dynamo\1.3\packages)에 직접 복사할 수 있습니다.

패키지로 제공되는 확장

개요

Dynamo 확장은 일반 Dynamo 노드 라이브러리처럼 패키지 관리자에 배포할 수 있습니다. 설치된 패키지에 뷰 확장이 포함되어 있으면 확장은 Dynamo가 로드될 때 런타임에 로드됩니다. Dynamo 콘솔을 확인하여 확장이 제대로 로드되었는지 확인할 수 있습니다.

패키지 구조

확장 패키지의 구조는 다음을 포함하는 일반 패키지와 동일합니다.

확장을 이미 빌드했다고 가정하면 최소한 .NET 어셈블리와 매니페스트 파일이 있어야 합니다. 어셈블리에는 IViewExtension 또는 IExtension을 구현하는 클래스가 포함되어 있어야 합니다. 매니페스트 .XML 파일은 확장을 실행하기 위해 인스턴스화해야 하는 클래스를 Dynamo에 알려줍니다. 패키지 관리자가 확장을 올바르게 찾으려면 매니페스트 파일이 어셈블리 위치 및 이름과 정확하게 일치해야 합니다.

어셈블리 파일은 bin 폴더에 배치하고 매니페스트 파일은 extra 폴더에 배치합니다. 이 폴더에 추가 자산을 배치해도 됩니다.

매니페스트 .XML 파일의 예:

업로드하기

위에서 설명한 하위 디렉토리가 포함된 폴더가 있으면 패키지 관리자로 푸시(업로드)할 수 있습니다. 한 가지 주의해야 할 사항은 현재 Dynamo 샌드박스에서는 패키지를 게시할 수 없다는 점입니다. 즉, Dynamo Revit을 사용해야 합니다. Dynamo Revit에서 패키지 => 새 패키지 게시로 이동합니다. 그러면 패키지를 연결할 Autodesk 계정에 로그인하라는 메시지가 표시됩니다.

이때 패키지/확장과 관련된 모든 필수 필드를 입력하는 일반 게시 패키지 창이 나타납니다. 어셈블리 파일 중 노드 라이브러리로 표시된 파일이 없는지 확인해야 하는 매우 중요한 추가 단계가 하나 있습니다. 이 단계는 가져온 파일(위에서 생성한 패키지 폴더)을 마우스 오른쪽 버튼으로 클릭하여 수행할 수 있습니다. 이 옵션을 선택(또는 선택 취소)하는 옵션을 제공하는 상황에 맞는 메뉴가 나타납니다. 모든 확장 어셈블리는 선택 취소해야 합니다.

공개적으로 게시하기 전에 항상 로컬에 게시하여 모든 것이 예상대로 작동하는지 확인해야 합니다. 예상대로 작동하는 것을 확인한 후 게시를 선택하면 게시할 준비가 완료된 것입니다.

끌어오기

패키지가 성공적으로 업로드되었는지 확인하려면 게시 단계에서 지정한 이름 및 키워드를 사용하여 패키지를 검색할 수 있어야 합니다. 마지막으로, 동일한 확장을 사용하려면 작동하기 전에 Dynamo를 재부팅해야 합니다. 일반적으로 이러한 확장에는 Dynamo가 부팅될 때 지정되는 매개변수가 필요합니다.

끌어오기 요청

Dynamo는 커뮤니티의 창의성과 헌신에 의존하고 있으며, Dynamo 팀은 기여자들이 가능성을 탐색하고, 아이디어를 테스트하고, 커뮤니티에 피드백을 제공하도록 독려합니다. 혁신은 적극 권장되지만, 변경 사항은 Dynamo의 사용 편의성을 높이고 이 문서에 정의된 지침을 충족하는 경우에만 병합됩니다. 이점이 적은 변경 사항은 병합되지 않습니다.

끌어오기 요청에 대한 기대 사항

Dynamo 팀은 끌어오기 요청이 다음과 같은 몇 가지 지침을 준수하기를 기대합니다.

및 을 준수합니다.
새 기능을 추가할 때 단위 테스트를 포함합니다.
버그를 수정할 때 현재 동작이 작동하지 않는 방식을 강조 표시하는 단위 테스트를 추가합니다
한 가지 이슈를 집중적으로 논의합니다. 새 주제 또는 관련 주제가 발생하면 새 이슈를 생성합니다.

다음은 수행하지 말아야 하는 행동에 대한 몇 가지 지침입니다.

갑자기 대규모 끌어오기 요청을 진행하지 않습니다. 대신, 이슈를 제기하고 논의를 시작하여 많은 시간을 투자하기 전에 방향에 대해 서로가 합의할 수 있도록 합니다.
작성하지 않은 코드를 커밋하지 않습니다. Dynamo에 추가하기에 적합하다고 생각되는 코드를 발견하면 계속 진행하기 전에 이슈를 제기하고 논의를 시작합니다.
라이센스 관련 파일 또는 헤더를 변경하는 PR을 제출하지 않습니다. PR에 문제가 있다고 생각되면 이슈를 제출해 주십시오. 그러면 주의를 기울여 검토하겠습니다.
이슈를 제기하고 먼저 Autodesk와 논의를 하지 않은 상태에서 API를 추가하지 않습니다.

끌어오기 요청 템플릿 작성하기

끌어오기 요청을 제출할 때는 을 사용하십시오. PR을 제출하기 전에, 다음과 같이 목적에 대한 설명이 명확하고 모든 선언이 사실인지 확인하십시오.

이 PR 이후 코드베이스의 상태가 더 개선되었습니다.
에 따라 문서화되었습니다.
이 PR에 포함된 테스트 수준이 적절합니다.
사용자 대상 문자열(있는 경우)이 *.resx 파일로 추출됩니다.
모든 테스트는 셀프 서비스 CI를 사용하여 통과됩니다.
UI 변경에 대한 스냅샷(있는 경우)
API에 대한 변경 사항은 을 따르며 문서에 설명되어 있습니다.

끌어오기 요청에 대한 적절한 검토자는 Dynamo 팀에서 배정합니다.

끌어오기 요청 검토 프로세스

끌어오기 요청을 제출하고 나면 검토 프로세스에 계속 참여해야 할 수 있습니다. 다음 검토 기준을 숙지하십시오.

Dynamo 팀은 한 달에 한 번 모여서 가장 오래된 끌어오기 요청부터 최신 끌어오기 요청까지 검토합니다.
검토된 끌어오기 요청에 소유자의 변경이 필요한 경우 PR 소유자는 30일 이내에 응답해야 합니다. 다음 세션까지 PR에 대한 활동이 진행되지 않으면 팀에서 종료하거나 유용성에 따라 팀원이 넘겨받습니다.
끌어오기 요청은 Dynamo의 기본 PR 템플릿을 사용해야 합니다.
모든 선언이 충족되었지만 Dynamo PR 템플릿이 완전히 작성되지 않은 끌어오기 요청은 검토되지 않습니다.

Dynamo Revit 커밋 cherry-pick하기

Revit의 여러 버전이 출시되어 있으므로 여러 버전의 Revit에서 새 기능을 사용할 수 있도록 특정 DynamoRevit 릴리즈 분기에 변경 사항을 cherry-pick해야 할 수 있습니다. 검토 프로세스에서 기여자는 Dynamo 팀이 지정한 대로 다른 DynamoRevit 분기에 검토된 커밋을 cherry-pick할 책임이 있습니다.

예제

Dynamo를 개발하는 방법에 대한 예제를 보려면 아래 리소스를 검토하십시오.

샘플 리포지토리

이러한 샘플은 자체 프로젝트를 시작하는 데 사용할 수 있는 Visual Studio 템플릿입니다.

: 기본 ZeroTouch 노드에 대한 템플릿입니다.
- 여러 출력 반환:
- Dynamo의 기본 형상 객체 사용:
- 예제 특성(조회 노드):
: 기본 NodeModel 노드 및 뷰 사용자 지정을 위한 템플릿입니다.
- 기본 NodeModel 템플릿:
  - 노드 속성 정의(입력/출력 이름, 설명, 유형):
  - 입력이 없는 경우 null 노드 반환:
  - 함수 호출 생성:
- 기본 NodeModel 뷰 사용자 지정 템플릿: , , ,
  - 요소를 업데이트해야 함을 UI에 알림:
  - NodeModel 사용자 지정:
  - 슬라이더 속성 정의:
  - 슬라이더에 대한 상호 작용 논리 확인:
: ZeroTouch, 사용자 지정 UI, 테스트 및 뷰 확장을 위한 템플릿입니다.
- - 기본 사용자 지정 UI 노드 생성:
  - 드롭다운 메뉴 생성:
- - 시스템 테스트:
  - ZeroTouch 테스트:
- :
  - 형상 렌더링에 영향을 주는 IGraphicItem을 구현하는 노드를 포함한 ZeroTouch 노드의 예제:
  - IRenderPackage를 사용하여 형상에 색상을 지정하는 ZeroTouch 노드의 예제:
- : MenuItem을 클릭할 때 모델리스 창을 표시하는 IViewExtension 구현
: NodeModel을 사용한 고급 Dynamo 패키지 개발을 위한 템플릿입니다.
- 필수 샘플:
- 형상 샘플:
- UI 샘플: