Visual Studio プロジェクトを開始できたので、セルの矩形グリッドを作成するカスタム ノードのビルド方法について説明します。矩形グリッドは複数の標準ノードを使用して作成できますが、このカスタム ノードは Zero-Touch ノードに簡単に含めることができる便利なツールです。通芯とは異なり、セルは、中心点を基点にスケールを変更したり、コーナーの頂点がクエリーされたり、面を構成することができます。

この例では、Zero-Touch ノードを作成する際に注意するべき機能と概念を紹介します。カスタム ノードをビルドして Dynamo に追加した後は、「Zero-Touch の詳細を確認する」ページの、「既定の入力値」、「複数の値を返す」、「ドキュメント」、「オブジェクト」、「Dynamo のジオメトリ タイプを使用する」、および「マイグレーション」セクションで詳細を確認してください。

カスタムの矩形グリッド ノード

グリッド ノードのビルドを開始するには、新しい Visual Studio クラス ライブラリ プロジェクトを作成します。プロジェクトの設定方法の詳細な説明については、「スタートアップ」ページを参照してください。

1. プロジェクト タイプとして Class Library を選択します

2. プロジェクトに CustomNodes という名前を付けます

ジオメトリを作成するため、適切な NuGet パッケージを参照する必要があります。NuGet パッケージ マネージャから ZeroTouchLibrary パッケージをインストールします。このパッケージは、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; で、ZeroTouchLibrary パッケージにある ProtoGeometry.dll を参照します。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 があるか確認します。正常にビルドされている場合は、Dynamo に .dll を追加できます。

1. Dynamo ライブラリ内のカスタム RectangularGrids ノード。

2. キャンバス上のカスタム ノード。

3. Dynamo に .dll を追加するための[追加]ボタン。

カスタム ノードの修正

上記の例では、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 ノードの開発、および注意すべき問題について詳しく説明します。

NodeModel ベースのノードは、Zero-Touch ノードよりも大幅に柔軟性に優れ強力です。この例では、矩形のサイズをランダム化する統合されたスライダを追加して、Zero-Touch グリッド ノードのレベルを高めます。

スライダでセルのスケールをそのサイズに対して相対的に変更するため、スライダで正確な範囲を設定する必要はありません。

モデル - ビュー - ビューモデル パターン

Dynamo は、UI をバックエンドから分離しておくためのモデル - ビュー - ビューモデル(MVVM)ソフトウェア アーキテクチャ パターンに基づいています。ZeroTouch ノードを作成する場合は、Dynamo はノードのデータとその UI の間でデータ バインドを実行します。カスタム UI を作成するには、データバインド ロジックを追加する必要があります。

大まかには、Dynamo では次の 2 つのパーツでモデルとビューの関係を確立します。

• ノードのコア ロジック(「モデル」)を確立する NodeModel クラス

• NodeModel の表示方法(「ビュー」)をカスタマイズする INodeViewCustomization クラス

NodeModel オブジェクトには既にビューとモデルの関連付け(NodeViewModel)があるため、検討するのはカスタム UI のモデルとビューのみです。

NodeModel を実装する方法

NodeModel ノードには Zero-Touch ノードと大きく異なる点がいくつかあり、この例でそれを説明します。UI のカスタマイズに進む前に、まず NodeModel ロジックをビルドします。

1.プロジェクト構造を作成する。

NodeModel ノードは関数のみを呼び出すことができるため、NodeModel と関数を別のライブラリに分割する必要があります。Dynamo パッケージでこの操作を行う標準的な方法として、それぞれ別のプロジェクトを作成します。まず、プロジェクトを包含する新しいソリューションを作成します。

1. File > New > Project を選択します。

2. Other Project Types を選択して Solution オプションを表示します。

3. Blank Solution を選択します。

4. ソリューションに CustomNodeModel という名前を付けます。

5. Ok を選択します。

ソリューションで 2 つの 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 は、後で説明する UI のカスタマイズに使用し、ZeroTouchLibrary はジオメトリの作成に使用します。パッケージは、プロジェクトに個別に追加できます。これらのパッケージには依存関係があるため、Core および DynamoServices が自動的にインストールされます。

1. プロジェクトを右クリックして、Manage NuGet Packages を選択します。

2. そのプロジェクトに必要なパッケージのみをインストールします。

Visual Studio は、参照した NuGet パッケージをビルド フォルダにコピーします。これを false に設定できるため、パッケージ内に不要なファイルはありません。

1. Dynamo NuGet パッケージを選択します。

2. 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 ノードとは異なるところです。それぞれの機能について説明します。

• Name、Category、InPort/OutPort の名前、InPort/OutPort のタイプ、説明などの、Node 属性を指定します。

• public class GridNodeModel : NodeModel は、NodeModel クラスを Dynamo.Graph.Nodes から継承するクラスです。

• public GridNodeModel() { RegisterAllPorts(); } は、ノードの入力と出力を登録するコンストラクタです。

• BuildOutputAst() は、AST (抽象構文ツリー)を返します。これは、NodeModel ノードからデータを返すために必要な構造です。

• 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 グリッドのケース スタディに非常に似ていますが、次の点のみ異なります。

• [IsVisibleInDynamoLibrary(false)] によって Dynamo には後に続くメソッドとクラスが「見えなく」なります。これは、関数が既に CustomNodeModel から呼び出されているためです。

NuGet パッケージの参照の追加と同様に、CustomNodeModel は関数を呼び出すために CustomNodeModelFunction を参照する必要があります。

CustomNodeModel の using ステートメントは、関数を参照するまで非アクティブになります。

1. CustomNodeModel を右クリックして、Add > Reference を選択します。

2. Projects > Solution を選びます。

3. CustomNodeModelFunction をオンにします。

4. [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> にスライダを追加します。

1. CustomNodeModel を右クリックして、Add > New Item を選択します。

2. WPF を選択します。

3. ユーザ コントロールに Slider という名前を付けます。

4. [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 ファイルの In で定義されています。Minimum および Maximum__ の属性は、このスライダの数値範囲を定義します。

• <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.パッケージとして構成する

プロジェクトをビルドする前に、最後の手順として、pkg.json ファイルを追加して Dynamo でパッケージの読み込みができるようにします。

1. CustomNodeModel を右クリックして、Add > New Item を選択します。

2. Web を選択します。

3. JSON File を選択します。

4. ファイルに pkg.json という名前を付けます。

5. [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 から直接パッケージをビルドする方法については、「パッケージの配置」の章を参照してください。

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 ライブラリに追加のノードが作成されないように、空のプライベート コンストラクタを追加します。

• 単一の文字列を入力パラメータとして受け取る新しいメソッドを作成します。

• このメソッド内で、新しい Python エンジンをインスタンス化し、スクリプトの空のスコープを作成します。このスコープは、Python インタプリタのインスタンス内のグローバル変数と考えることができます。

• 次に、エンジンで Execute を呼び出して入力文字列とスコープをパラメータとして渡します。

• 最後に、スコープで GetVariable を呼び出し、返そうとしている値を含む変数の名前を Python スクリプトから渡して、スクリプトの結果を取得して返します。(詳細については、下の例を参照してください)

次のコードは、上記の手順の例を示しています。ソリューションをビルドすると、プロジェクトの bin フォルダに新しい .dll が作成されます。この .dll をパッケージの一部として、または File < Import Library... にナビゲートして Dynamo に読み込むことができます。

複数の出力

標準の Python ノードの制限事項として、出力ポートは 1 つしかありません。そのため、複数のオブジェクトを返す場合は、リストを作成してその中で各オブジェクトを取得する必要があります。ディクショナリを返すように上記の例を変更すると、必要な数だけ出力ポートを追加できます。ディクショナリの詳細については、「Zero-Touch の詳細を確認する」の「複数の値を返す」セクションを参照してください。

このノードを使用すると、直方体の体積と図心の両方を返すことができます。

次の手順で前の例を変更します。

• NuGet パッケージ マネージャから DynamoServices.dll への参照を追加します。

• 以前のアセンブリに加えて、System.Collections.Generic および Autodesk.DesignScript.Runtime を含めます。

• 出力を含むディクショナリを返すように、メソッドの戻り値のタイプを変更します。

• 各出力は、スコープから個別に取得する必要があります(大きな出力セットに対して単純なループを設定することを検討してください)。

また、サンプルの Python スクリプトに出力変数(output2)を追加しています。これらの変数では任意の Python 命名規則を使用することができ、この例ではわかりやすくするために、厳密に output を使用しました。

拡張機能は、Dynamo エコシステムの強力な開発ツールです。開発者は、Dynamo の相互作用とロジックに基づいてカスタム機能を実行することができます。拡張機能は、2 つの主なカテゴリ、拡張機能とビュー拡張機能に分けることができます。名前が示すように、ビューの拡張機能フレームワークでは、カスタム メニュー項目を登録することで Dynamo UI を拡張することができます。通常の拡張機能は、UI を除いてビュー拡張機能と非常によく似た動作をします。たとえば、特定の情報を Dynamo コンソールに記録する拡張機能を作成することができます。このシナリオの場合、カスタム UI は必要ないため、通常の拡張機能を使用して実現することができます。

拡張機能のケース スタディ

DynamoSamples GitHub リポジトリの SampleViewExtension のサンプルに従って、グラフ内のアクティブなノードをリアルタイムで表示する、簡易なモードレス ウィンドウを作成するために必要な手順を説明します。ビュー拡張機能には、ウィンドウの UI を作成し、ビュー モデルに値をバインドする必要があります。

1. GitHub リポジトリの SampleViewExtension のサンプルに従って開発された、ビュー拡張機能ウィンドウ。

サンプルを最初から作成しますが、DynamoSamples リポジトリをダウンロードしてビルドすることで、参照として使用することもできます。

この手順では、DynamoSamples/src/ にある SampleViewExtension という名前のプロジェクトを具体的に参照します。

ビュー拡張機能を実装するには

ビュー拡張機能には、次の 3 つの主要な部分があります。

• IViewExtension を実装する、クラスとビュー モデルを作成するクラスを含むアセンブリ

• 実行時に、このアセンブリを検索する場所と拡張子のタイプを Dynamo に通知する .xml ファイル

• グラフィックス表示にデータをバインドして、ウィンドウの外観を決定する .xaml ファイル

1.プロジェクトの構造を作成する

まず、新規の Class Library プロジェクトを SampleViewExtension という名前で作成します。

1. File > New > Project を選択して新しいプロジェクトを作成します。

2. Class Library を選択します。

3. プロジェクトに SampleViewExtension という名前を付けます。

4. Ok を選択します。

このプロジェクトでは、2 つのクラスが必要です。1 つのクラスが IViewExtension を実装し、別のクラスは NotificationObject. IViewExtension を実装して、拡張機能がどのように配置、ロード、参照、および破棄するか、すべての情報を含めます。NotificationObject は、Dynamo と IDisposable での変更に関する通知を提供します。変更が発生すると、それに応じてカウントが更新されます。

1. SampleViewExtension.cs というクラス ファイルは IViewExtension を実装します。

2. SampleWindowViewMode.cs というクラス ファイルは NotificationObject を実装します。

IViewExtension を使用するには WpfUILibrary NuGet パッケージが必要です。このパッケージをインストールすると、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 } は、これから作成する .xaml ファイル内の Main Grid を参照して、ウィンドウ内のメイン グリッドのためのデータ コンテキストを設定します。

• Owner = p.DynamoWindow は、ポップアウト ウィンドウの所有者を Dynamo に設定します。つまり、新しいウィンドウは Dynamo に依存しているため、Dynamo の最小化、最大化、復元などの操作を行うと、新しいウィンドウでも同じ動作が実行されます。

• window.Show(); は、追加のウィンドウ プロパティが設定されたウィンドウを表示します。

3.ビュー モデルを実装する

ウィンドウの基本パラメータをいくつか設定することができました。次に、さまざまな Dynamo 関連のイベントに応答するためのロジックを追加し、これらのイベントに基づいて UI を更新するように指示します。次のコードを、SampleWindowViewModel.cs クラス ファイルにコピーします。

このビュー モデル クラスの実装は、CurrentWorkspaceModel を確認し、ワークスペースにノードが追加または削除されたときにイベントを発生させます。これにより、データが変更され、更新が必要であることを UI またはバインド要素に通知するプロパティの変更が発生します。ActiveNodeTypes ゲッターを呼び出すことで、内部で追加のヘルパー関数 getNodeTypes() が呼び出されます。この関数は、キャンバス上のすべてのアクティブなノードを反復処理し、これらのノードの名前を含む文字列を生成します。次にこの文字列を、ポップアウト ウィンドウに表示される .xaml ファイル内のバインドに返します。

拡張機能のコア ロジックを定義したため、ウィンドウの外観の詳細を .xaml ファイルで指定できるようになりました。単に必要なのは、TextBlock Text にバインドされている ActiveNodeTypes プロパティを介して文字列を表示する、簡易なウィンドウです。

1. プロジェクトを右クリックして次を選択します: Add > New Item...

2. ウィンドウを作成するために変更するユーザ コントロール テンプレートを選択します。

3. 新しいファイル名を SampleWindow.xaml にします。

4. Add を選択します。

ウィンドウの .xaml コードでは、テキスト ブロックに SelectedNodesText をバインドする必要があります。SampleWindow.xaml に、次のコードを追加します。

• Text="{Binding ActiveNodeTypes}" は、SampleWindowViewModel.cs 内のプロパティ値 ActiveNodeTypes に対して、ウィンドウの TextBlock Text 値をバインドします。

ここで、.xaml C# バッキング ファイル SampleWindow.xaml.cs のサンプル ウィンドウを初期化します。SampleWindow.xaml に、次のコードを追加します。

ビュー拡張機能は、構築して Dynamo に追加する準備が整いました。Dynamo には、xml ファイルが必要です。出力を .dll 拡張子として登録するためのファイルです。

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 の Core インストール フォルダ C:\Program Files\Dynamo\Dynamo Core\1.3\viewExtensions にある Dynamo のビュー拡張機能フォルダにコピーします。extensions と viewExtensions には別々のフォルダが存在することに注意が必要です。xml ファイルを誤ったフォルダに配置すると、実行時に正しくロードされない可能性があります。

1. Dynamo のビュー拡張機能フォルダにコピーされた .xml ファイル

ここではビュー拡張機能の基本的な概要について紹介しました。より高度なケース スタディについては、GitHub のオープン ソース プロジェクトである DynaShape パッケージを参照してください。このパッケージでは、Dynamo モデル ビューでライブ編集を可能にするビュー拡張機能を使用しています。

開発に取り組む前に、新しいプロジェクトのための強固な基盤を築くことが重要です。Dynamo 開発者のコミュニティには複数のプロジェクト テンプレートがあり、ここから始めると便利ですが、プロジェクトをゼロから開始する方法を理解することはさらに重要です。プロジェクトをゼロから構築すると、開発プロセスをより深く理解できます。

Visual Studio プロジェクトを作成する

Visual Studio は、プロジェクトの作成、参照の追加、.dlls のビルド、デバッグを行うことができる強力な IDE です。新しいプロジェクトを作成する際に、Visual Studio ではプロジェクトを編成するための構造であるソリューションも作成します。複数のプロジェクトを、単一のソリューション内に配置し、まとめてビルドできます。ZeroTouch ノードを作成するには、C# クラス ライブラリを記述して .dll をビルドする新しい Visual Studio プロジェクトを開始する必要があります。

Visual Studio の新しいプロジェクトのウィンドウ

1. まず、Visual Studio を開いて、File > New > Project で新しいプロジェクトを作成します。

2. Class Library プロジェクト テンプレートを選択します。

3. プロジェクトに名前を付けます(この例ではプロジェクトに MyCustomNode という名前を付けています)。

4. プロジェクトのファイル パスを設定します。この例では、既定の場所のままにします。

5. Ok を選択します。

Visual Studio では自動的に C# ファイルを作成して開きます。適切な名前を付け、ワークスペースを設定し、既定のコードを次の乗算方法で置き換える必要があります。

1. [View]からソリューション エクスプローラ ウィンドウと出力ウィンドウを開きます。

2. 右側のソリューション エクスプローラで、ファイル Class1.cs の名前を SampleFunctions.cs に変更します。

3. 乗算関数として上記のコードを追加します。Dynamo での C# クラスの読み込み方法については、後で詳しく説明します。

4. ソリューション エクスプローラ: ここでプロジェクト内のすべてにアクセスできます。

5. 出力ウィンドウ: ビルドが成功したかどうかを後で確認する場合に必要になります。

次の手順ではプロジェクトをビルドしますが、その前に設定をいくつか確認する必要があります。まず、プロジェクトのプロパティで、[Platform target]に Any CPU または x64 が選択され、Prefer 32-bit がオフになっていることを確認します。

1. Project > "ProjectName" Properties を選択して、プロジェクトのプロパティを開きます。

2. Build ページを選択します。

3. ドロップダウン メニューから Any CPU または x64 を選択します。

4. Prefer 32-bit がオフになっていることを確認します。

これで、.dll を作成するためにプロジェクトをビルドできるようになりました。これを行うには、[Build]メニューから[Build Solution]を選択するか、ショートカット CTRL+SHIFT+B を使用します。

1. Build > Build Solution を選択します。

2. 出力ウィンドウを確認すると、プロジェクトが正常にビルドされたかどうかを判断できます。

プロジェクトが正常にビルドされた場合、プロジェクトの bin フォルダに MyCustomNode という名前の .dll が作成されます。この例では、プロジェクトのファイル パスを Visual Studio の既定である c:\users\username\documents\visual studio 2015\Projects のままにしました。プロジェクトのファイル構造を確認します。

1. bin フォルダには、Visual Studio でビルドされた .dll が含まれています。

2. Visual Studio プロジェクト ファイル。

3. クラス ファイル。

4. ソリューション構成を Debug に設定したため、.dll は bin\Debug に作成されます。

これで、Dynamo を開いて .dll を読み込むことができるようになりました。追加機能を使用して、プロジェクトの bin の場所にナビゲートし、.dll を選択して開きます。

1. .dll を読み込むため、[追加]ボタンを選択します。

2. プロジェクトの場所にナビゲートします。プロジェクトは、Visual Studio の既定のファイル パス C:\Users\username\Documents\Visual Studio 2015\Projects\MyCustomNode にあります。

3. 読み込む MyCustomNode.dll を選択します。

4. [Open]をクリックして .dll をロードします。

ライブラリに MyCustomNode という名前のカテゴリが作成されている場合は、.dll が正常に読み込まれています。しかし、単一のノードを作成しようとしたところ、Dynamo で 2 つのノードが作成されました。次のセクションでは、このようになる理由と、Dynamo による .dll の読み込みについて説明します。

1. Dynamo ライブラリ内の MyCustomNode。ライブラリのカテゴリは、.dll の名前によって決まります。

2. キャンバス上の SampleFunctions.MultiplyByTwo。

Dynamo によるクラスとメソッドを読み込む仕組み

Dynamo は .dll をロードする際、すべてのパブリック静的メソッドをノードとして公開します。コンストラクタ、メソッド、およびプロパティは、それぞれ Create ノード、Action ノード、および Query ノードに変換されます。この乗算の例では、MultiplyByTwo() メソッドが Dynamo で Action ノードになります。これは、ノードの名前がそのメソッドとクラスに基づいて付けられているためです。

1. 入力には、メソッドのパラメータ名に基づいて inputNumber という名前が付けられています。

2. 出力に既定で double という名前が付けられているのは、これが返されるデータ タイプであるためです。

3. ノードに SampleFunctions.MultiplyByTwo という名前が付けられているのは、クラス名とメソッド名であるためです。

上記の例では、さらに SampleFunctions という Create ノードが作成されました。これは、明示的にコンストラクタを指定しなかったために自動的に作成されたことが原因です。これを回避するには、SampleFunctions クラスに空のプライベート コンストラクタを作成します。

1. Dynamo が Create ノードとしてメソッドを読み込みました。

Dynamo NuGet パッケージの参照設定を追加する

乗算ノードは非常に単純なため、Dynamo への参照設定は必要ありません。たとえば、ジオメトリを作成するために Dynamo の機能にアクセスする場合は、Dynamo NuGet パッケージを参照する必要があります。

Visual Studio プロジェクトでこれらのパッケージを参照するには、上記のリンクで NuGet からパッケージをダウンロードして .dll を手動で参照するか、Visual Studio の NuGet パッケージ マネージャ を使用します。まず、Visual Studio で NuGet を使用してインストールする方法について説明します。

1. Tools > NuGet Package Manager > Manage NuGet Packages for Solution... を選択して NuGet パッケージ マネージャを開きます。

次の図が NuGet パッケージ マネージャです。このウィンドウには、プロジェクトにインストールされているパッケージが表示され、ユーザは他のパッケージを参照できます。DynamoServices パッケージの新しいバージョンがリリースされた場合は、ここからパッケージを更新できます。前のバージョンに戻すこともできます。

1. [参照]を選択し、DynamoVisualProgramming を検索して Dynamo パッケージを表示します。

2. Dynamo パッケージです。いずれかを選択すると、そのパッケージの現在のバージョンと内容の説明が表示されます。

3. 必要なパッケージのバージョンを選択し、[インストール]をクリックします。これにより、作業中の特定のプロジェクトにパッケージがインストールされます。Dynamo の最新の公式リリースであるバージョン 1.3 を使用しているため、対応するパッケージのバージョンを選択します。

ブラウザからダウンロードしたパッケージを手動で追加するには、ソリューション エクスプローラから Reference Manager を開いてパッケージを参照します。

1. [References]を右クリックして、[Add Reference]を選択します。

2. [Browse]を選択して、パッケージの場所にナビゲートします。

Visual Studio が適切に構成され、Dynamo に .dll が正常に追加されたため、今後、コンセプトの強固な基盤となります。これは第一歩にすぎないため、引き続きカスタム ノードの作成方法の詳細について確認してください。

Dynamo のソースは、クローンを作成して他のユーザに提供するために、GitHub でホストされています。この章では、git を使用してリポジトリをクローン作成する方法、Visual Studio を使用してソース ファイルをコンパイルする方法、ローカル ビルドを実行およびデバッグする方法、および GitHub から新しい変更を取得する方法について説明します。

GitHub で Dynamo リポジトリを検索する

GitHub は、利用者間の変更を追跡し、作業を調整するためのバージョン管理システムである に基づくホスト サービスです。git は、Dynamo のソース ファイルをダウンロードして、いくつかのコマンドでそれらを更新するために活用できるツールです。この方法を使用すると、更新のたびにソース ファイルをダウンロードし、手動で置き換えるといった面倒な作業を回避できます。git バージョン管理システムは、ローカルおよびリモート間のコード リポジトリの違いを追跡します。

Dynamo のソースは、次のリポジトリの DynamoDS GitHub でホストされます。

Dynamo ソース ファイルです。

1. リポジトリ全体をクローン作成またはダウンロード

2. 他の DynamoDS リポジトリを表示

3. Dynamo のソース ファイル

4. git 固有ファイル

git を使用して Dynamo リポジトリをプルする

クローン作成する Dynamo リポジトリの URL が必要です。これは、リポジトリのページの「クローンまたはダウンロード」ボタンにあります。URL をコピーしてコマンド プロンプトに貼り付けます。

1. 「クローンまたはダウンロード」を選択する

2. URL をコピーする

git がインストールされていると、Dynamo リポジトリをクローン作成できます。はじめに、コマンド プロンプトを開きます。次に、フォルダの変更コマンド cd を使用して、クローン作成するソース ファイルのあるフォルダに移動します。この例では、Github というフォルダを Documents に作成します。

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 リポジトリのマスター ブランチと同じに見える必要があります。

1. Dynamo のソース ファイル

2. git ファイル

Visual Studio を使用してリポジトリをビルドする

ソース ファイルがローカル マシンにクローン化されたため、Dynamo の実行可能ファイルを構築できるようになりました。これを進めるには、Visual Studio IDE をセットアップし、.NET Framework と DirectX がインストールされていることを確認する必要があります。

• ローカルの Dynamo リポジトリ(Dynamo\tools\install\Extra\DirectX\DXSETUP.exe)から、Microsoft DirectX をインストールします

.NET および DirectX は、すでにインストールされている可能性があります。

インストールがすべて完了したら、Visual Studio を起動して、Dynamo\src にある Dynamo.All.sln ソリューションを開きます。

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 が正常にビルドを完了すると、DynamoSandbox.exe ファイルを含む bin フォルダが Dynamo リポジトリに作成されます。このサンプルでは、デバッグ オプションを使用してビルドしているため、実行可能ファイルは bin\AnyCPU\Debug に配置されます。これ実行すると、Dynamo のローカル ビルドが開きます。

1. 先ほどビルドした DynamoSandbox の実行可能ファイルです。これを実行して Dynamo を起動します。

これで、Dynamo の開発を始めるための設定はほぼ完了しました。

Visual Studio を使用してローカル ビルドをデバッグする

デバッグ用の 2 つのオプション、スタンドアロンの Dynamo アプリケーション、DynamoSandbox について説明します。

• Visual Studio から直接 Dynamo をビルドして起動する

• Dynamo の実行中のプロセスに Visual Studio をアタッチする

Visual Studio から Dynamo を起動すると、必要に応じてデバッグ セッションごとにソリューションが再構築されるため、ソースに変更を加えた場合は、デバッグ時に反映されます。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 でプロジェクトのソース ファイルを開き、Attach to Process デバッグ メニュー項目を使用して実行中の Dynamo プロセスにアタッチします。

実行中のプロセスを 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. ここでは、ローカル リポジトリがリモートからの変更によって更新されていることが確認できます。

更新プログラムの取得に加えて、さらに 4 つの git ワークフローについて理解しておく必要があります。

• Dynamo リポジトリをフォークして、元のリポジトリとは別にコピーを作成します。ここで行った変更は元のリポジトリには影響せず、プル リクエストを使用して更新を取得または送信することができます。フォークは git コマンドではありませんが、GitHub が追加するワークフローです。フォーク、プル リクエスト モデルは、オープン ソース プロジェクトにオンラインで貢献するための最も一般的なワークフローの 1 つです。Dynamo に寄与したいと考えている場合は、学習する価値があります。

• ブランチ - ブランチの他の作業か切り離して、実験や新機能に関して作業します。これにより、プル リクエストの送信が容易になります。

• 作業単位の完了後、および元に戻したい可能性のある変更を行った後は、頻繁にコミットを行ってください。コミット レコードはリポジトリに変更され、メインの Dynamo リポジトリにプル リクエストを行うときに表示されます。

• メインの Dynamo リポジトリに正式に変更を提案する準備ができたら、プル リクエストを作成します。

Dynamo チームには、プル リクエストの作成に関する具体的な手順があります。対処する項目の詳細については、このドキュメントの「プル リクエスト」セクションを参照してください。

Dynamo 用のパッケージとしてパブリッシュするアセンブリを開発している場合は、必要なすべてのアセットをグループ化し、パッケージと互換性のあるフォルダ構造に配置するように、プロジェクトを設定できます。これにより、プロジェクトをパッケージとしてすばやくテストし、ユーザの操作をシミュレーションすることができます。

パッケージ フォルダに直接ビルドする方法

Visual Studio でパッケージをビルドするには、次の 2 つの方法があります。

• xcopy または Python スクリプトを使用して必要なファイルをコピーするビルド後のイベントを、プロジェクト設定ダイアログで追加します。

• .csproj ファイルで「AfterBuild」ビルド ターゲットを使用して、ファイルおよびフォルダのコピー タスクを作成します。

「AfterBuild」は、ビルド マシンでは使用できない可能性のあるファイル コピーに依存しないため、このような操作に適した方法であり、このガイドではこの方法について説明しています。

AfterBuild メソッドを使用してパッケージ ファイルをコピーする

ソース ファイルがパッケージ ファイルとは別のファイルになるように、リポジトリ内のフォルダ構造を設定します。CustomNodeModel ケース スタディで作業しているため、Visual Studio プロジェクトと関連するすべてのファイルを新しい src フォルダに配置します。プロジェクトによって生成されるすべてのパッケージをこのフォルダに保存することになります。フォルダ構造は次のようになります。

1. プロジェクト ファイルを新しい src フォルダに移動します。

ターゲットが(他のプロジェクト ファイルではなく) CustomNodeModel.csproj ファイルに追加されていること、およびプロジェクトに既存のビルド後の設定がないことを確認する必要があります。

1. AfterBuild ターゲットを終了タグ </Project> の前に配置します。

<ItemGroup> セクションでは、特定のファイル タイプを表す変数がいくつか定義されています。たとえば、変数 Dll は、出力フォルダ内にある、拡張子が .dll のすべてのファイルを表します。

Copy タスクは、すべての .dll ファイルをフォルダにコピーします。具体的にはビルド先のパッケージ フォルダにコピーします。

Dynamo パッケージには通常、Dynamo カスタム ノード用の dyf フォルダ、およびイメージなどのその他のアセット用の extra フォルダがあります。これらのフォルダを作成するには、MakeDir タスクを使用する必要があります。このタスクは、フォルダが存在しない場合にそのフォルダを作成します。このフォルダにファイルを手動で追加できます。

プロジェクトをビルドすると、プロジェクト フォルダには、以前に作成された src フォルダの横に packages フォルダが作成されます。packages フォルダ内には、パッケージに必要なものがすべて格納されているフォルダがあります。また、pkg.json ファイルをパッケージ フォルダにコピーして、Dynamo でパッケージをロードできるようにする必要があります。

1. AfterBuild ターゲットが作成した新しいパッケージ フォルダ

2. プロジェクトの既存の src フォルダ

3. AfterBuild ターゲットによって作成された dyf および extra フォルダ

4. pkg.json ファイルを手動でコピーします。

これで、Dynamo のパッケージ マネージャを使用してパッケージをパブリッシュしたり、Dynamo のパッケージ フォルダ <user>\AppData\Roaming\Dynamo\1.3\packages に直接コピーできるようになりました。

経験のレベルに関係なく、Dynamo プラットフォームはすべてのユーザが開発に参加できるように設計されています。さまざまな能力やスキル レベルを対象とする開発オプションがあり、それぞれの目的によって利点と欠点があります。ここでは開発オプションの概要と、その選び方について説明します。

次の 3 つの開発環境があります: Visual Studio、Python Editor、Code Block DesignScript

オプションの選び方について

Dynamo の開発オプションは、主に Dynamo 向け_の_開発と、Dynamo で の開発の 2 つに分類されます。この 2 つのカテゴリは、Dynamo IDE を使用して作成されたコンテンツを Dynamo で使用する「Dynamo での開発」と、外部ツールを使用して作成されたコンテンツを Dynamo に読み込んで使用する「Dynamo 向けの開発」を意味します。このガイドでは、Dynamo 向け の開発に焦点を当てていますが、すべてのプロセスのリソースについて以下で説明します。

Dynamo 向けの開発

これらのノードを使用することにより、最高レベルのカスタマイズが可能になります。多くのパッケージがこの方法を使用して構築されており、Dynamo のソースに貢献するために必要な手法です。このガイドでは、これらの構築プロセスについて説明します。

• Zero-Touch ノード

• NodeModel 派生ノード

• 拡張機能

次の説明では、Zero-Touch ノードおよび NodeModel ノードの開発環境として Visual Studio を使用します。

これから開発するプロジェクトがある Visual Studio インタフェース

Dynamo での開発

• Code Block はビジュアル プログラミング環境で DesignScript を公開し、柔軟なテキスト スクリプトとノード ワークフローを可能にします。Code Block の関数は、ワークスペース内の任意の機能から呼び出すことができます。

• カスタム ノードは、ノードの集合体またはグラフ全体のコンテナです。頻繁に使用するルーチンを収集し、コミュニティと共有するための効果的な手段です。

• Python ノードは、Code Block と同様の働きをするビジュアル プログラミング ワークスペースのスクリプト インタフェースです。Autodesk.DesignScript ライブラリでは、DesignScript と同様のドット表記を使用します。

Dynamo ワークスペースでの開発は、即座にフィードバックが得られる強力な手段です。

Python ノードを使用して Dynamo ワークスペースで開発する

それぞれの利点と欠点について

Dynamo の開発オプションは、カスタマイズの必要性に伴う複雑な作業に対応できるように設計されています。目的が Python で再帰スクリプトを記述するのか、完全にカスタム化したノード UI を構築するのかに関わらず、起動と実行に必要なものだけでコードを実装できるオプションがあります。

Dynamo の Code Block 、Python ノード、カスタム ノード

これらは、Dynamo のビジュアル プログラミング環境でコードを書く場合の簡単なオプションです。Dynamo のビジュアル プログラミング ワークスペースから、Python や DesignScript にアクセスでき、カスタム ノード内に複数のノードを含めることができます。

これらの方法を使用すると、次の操作が可能になります。

• セットアップは最小限のまま、Python または DesignScript の作成を開始します。

• Python ライブラリを Dynamo に読み込みます。

• Dynamo コミュニティで、Code Block、Python ノード、カスタム ノードをパッケージの一部として共有します。

Zero-Touch ノード

Zero-Touch とは、C# ライブラリを読み込むための単純なポイント アンド クリック操作のことです。Dynamo は、.dll のパブリック メソッドを読み取って Dynamo ノードに変換します。Zero-Touch ノードを使用して、独自のカスタム ノードおよびパッケージを開発できます。

この方法では、次の操作が可能になります。

• C# メソッドを記述し、Dynamo でノードとして簡単に使用することができます。

• パッケージ内の Dynamo コミュニティで C# ライブラリをノードとして共有できます。

NodeModel 派生ノード

これらのノードは、Dynamo の構造をさらに一歩前進させたものです。これらは NodeModel クラスに基づいて C# で記述されます。この方法は最も柔軟で強力ですが、ノードのほとんどの要素を明示的に定義する必要があることと、関数は別のアセンブリに存在する必要があります。

この方法では、次の操作が可能になります。

• スライダ、イメージ、カラーなど、完全にカスタマイズ可能なノード UI を作成します(ColorRange ノードなど)。

• Dynamo キャンバスにアクセスし、そこでの動作に影響を与えることができます。

• レーシングをカスタマイズします。

• Dynamo にパッケージとしてロードします。

Dynamo のバージョン管理と API の変更点について理解する(1.x → 2.x)

Dynamo は定期的に更新されるため、パッケージが使用する API の一部が変更される場合があります。既存のパッケージが正しく動作し続けるようにするためには、これらの変更を追跡することが重要になります。

パッケージのバイナリを配布する権限

Package Manager にアップロードされるパッケージに含まれる .dll に注意してください。パッケージの作成者が .dll を作成しなかった場合、それらを共有する権限が必要です。

パッケージにバイナリが含まれている場合、パッケージにバイナリが含まれていることをダウンロード時にユーザに確認する必要があります。

このガイドの目的について

このガイドは、Dynamo で Zero-Touch ノードを作成する方法から、拡張機能を構築する方法まで、C# 開発のさまざまな可能性の概要を説明することを目的としています。

GitHub の Dynamo ソース

追加で提供される開発者向けリソースとは

Dynamo: Dynamo の最新の安定したビルドと、毎日のビルドをダウンロードします

Dynamo GitHub: Dynamo は、GitHub 上で開発されたオープン ソースのプロジェクトです。

Dynamo GitHub Wiki: 開発者向けドキュメントにアクセスできる主要なリソースです。

ノードの命名規則は、Dynamo のカテゴリ、ノード、入力ポート、出力ポートに名前を付ける際の標準とガイドラインを提供します。

Dynamo 言語/API ガイド: 現在、Dynamo の API ドキュメントにはコア機能が記載されています

DynamoBIM: 追加情報、ラーニング コンテンツ、フォーラムについては、DynamoBIM の Web サイトを参照してください。

Dynamo ディクショナリすべての Dynamo ノードを検索できるデータベース

DesignScript 言語ガイド DesignScript を記述するための PDF 形式のガイド

このガイドに対する変更を提案したい場合

このドキュメントに対する提案をいつでも受け付けております。変更したい内容を、GitHub で直接作成することでリクエストすることができます。

Zero-Touch プロジェクトの作成方法を理解できたので、Dynamo GitHub にあるサンプル ZeroTouchEssentials を使用して、ノードの作成について詳しく説明します。

Dynamo の標準ノードの多くは基本的な Zero-Touch ノードです。上記のほとんどの Math、Color、DateTime ノードと同様です。

まず、 から ZeroTouchEssentials プロジェクトをダウンロードします。

Visual Studio で、ソリューション ファイル ZeroTouchEssentials.sln を開いてソリューションをビルドします。

ZeroTouchEssentials.cs ファイルには、Dynamo に読み込むメソッドがすべて含まれています。

Dynamo を開いて ZeroTouchEssentials.dll を読み込み、次の例で参照するノードを取得します。

既定の入力値

• メソッドのパラメータを既定値 inputNumber = 2.0 に設定します

1. ノードの入力ポートにカーソルを合わせると、既定値が表示されます。

複数の値を返す

複数の値を返すのは、複数の入力を作成するよりも少し複雑で、ディクショナリを使用して返す必要があります。ディクショナリのエントリはノードの出力側のポートになります。戻り値の複数のポートは次のように作成します。

• using System.Collections.Generic; を追加して Dictionary<> を使用します。

• using Autodesk.DesignScript.Runtime; を追加して、MultiReturn 属性を使用します。これは、DynamoServices NuGet パッケージから「DynamoServices.dll」を参照します。

• [MultiReturn(new[] { "string1", "string2", ... more strings here })] 属性をメソッドに追加します。文字列はディクショナリ内のキーを参照して、出力ポート名になります。

• 属性のパラメータ名に一致するキーを使用して関数から Dictionary<> を返します。return new Dictionary<string, object>

複数の出力を返すノードです。

1. ディクショナリのキーに入力した文字列に従って、2 つの出力ポートに名前が付けられています。

ドキュメント、ツールチップ、検索

ノードの関数、入力、出力、検索タグなどを記述したドキュメントを Dynamo ノードに追加することをお勧めします。追加するには、XML ドキュメント タグを使用します。XML ドキュメントは次のように作成されます。

• 3 つのスラッシュが先頭に付いたすべてのコメント テキストは、ドキュメントとみなされます

  • 例: /// Documentation text and XML goes here

• 3 つのスラッシュの後に、.dll の読み込み時に Dynamo が読み込むメソッドの上に XML タグを作成します。

  • 例: /// <summary>...</summary>

• Project > Project Properties > Build を選択して XML documentation file をオンにすることで、Visual Studio で XML ドキュメントを有効にします。

1. Visual Studio は、指定された場所に XML ファイルを生成します。

タグのタイプは次のとおりです。

• /// <summary>...</summary> は、ノードのメインのドキュメントであり、左側の検索サイド バーでノードの上にツールチップとして表示されます

• /// <param name="inputName">...</param> は、特定の入力パラメータのドキュメントを作成します。

• /// <returns>...</returns> は、出力パラメータのドキュメントを作成します。

• /// <returns name = "outputName">...</returns> は、複数の出力パラメータのドキュメントを作成します。

• /// <search>...</search> は、カンマ区切りのリストに基づいて、ノードを検索結果と一致させます。たとえば、メッシュを再分割するノードを作成する場合は、「mesh」、「subdivision」、「catmull-clark」などのタグを追加します。

入力と出力の説明と、ライブラリに表示される概要を含むサンプル ノードを次に示します。

このサンプル ノードのコードには次が含まれています。

1. ノードの概要。

2. 入力の説明。

3. 出力の説明。

オブジェクト

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 ジオメトリ オブジェクトは、関数に渡されるその他のオブジェクトと同様に使用されます。

曲線の長さを取得し、その値を倍にするノード。

1. このノードは、入力として Curve ジオメトリタイプを受け取ります。

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> 要素を指定します。

1. 右クリックして、Add > New Item を選択します。

2. XML File を選びます。

3. このプロジェクトでは、マイグレーション ファイルに ZeroTouchEssentials.Migrations.xml という名前を付けます。

このサンプル コードでは、GetClosestPoint という名前のノードが ClosestPointTo に変更されたことを Dynamo に伝えています。

ジェネリクス

Zero-Touch は現在、ジェネリクスの使用をサポートしていません。使用できますが、タイプが設定されていない場合には直接読み込まれるコードで使用できません。汎用的でタイプが設定されていないメソッド、プロパティ、またはクラスは公開できません。

下の例では、タイプ T の Zero-Touch ノードは読み込まれません。ライブラリの残りの部分を Dynamo に読み込むと、タイプの例外が失われます。

次の例では、タイプを設定して汎用的なタイプを使用すると、Dynamo に読み込まれます。

はじめに:

Dynamo 2.0 は主要なリリースであり、いくつかの API が変更または削除されました。中でも、ノードおよびパッケージの作成者に多大な影響をおよぼす変更の 1 つは、ファイル形式が JSON に移行されたことです。

Zero-Touch ノードの作成者が、パッケージを 2.0 で実行するために必要となる作業は、ほとんどないのが一般的です。

UI ノードと、NodeModel から直接派生したノードを 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 の 2 つのバージョンが同時に同じプロセスにロードされ、.net ランタイム エラーが発生したため、コンストラクタをマークするための [JsonConstructor] 属性を正しく使用できなかった。

• 現在の Dynamo バージョンとは異なるバージョンの DynamoServices.dll がパッケージにバンドルされており、.net ランタイムで [MultiReturn] 属性を識別できなくなっているために、さまざまな属性が設定されている Zero-Touch ノードを適用することができない。ノードは複数のポートではなく、単一のディクショナリ出力を返すことがあります。

2) コンソールでいくつかのエラーが発生した状態でグラフをロードすると、ノードが完全に失われる。

• これは、何らかの理由でシリアル化解除に失敗した場合に発生する可能性があります。必要なプロパティのみをシリアル化することをお勧めします。ロードや保存を必要としない複雑なプロパティに対して [JsonIgnore] を使用して、それらを無視することができます。function pointer, delegate, action, や event などのプロパティです。これらはシリアル化できないため、シリアル化解除に失敗し、ランタイム エラーが発生します。

詳細なアップグレード:

カスタム ノード 1.3 > 2.0

既知の問題:

• コメントは、行コメントではなくブロック コメントに変換されます。

• ショート タイプ名はフル ネームに置き換えられます。たとえば、カスタム ノードを再ロードするときにタイプを指定しなかった場合、var[]..[] - が既定のタイプとして表示されます。

Zero-Touch ノード 1.3 -> 2.0

• Dynamo 2.0 では、リストとディクショナリのタイプが分割され、リストとディクショナリを作成するための構文が変更されました。リストは [] を使用して初期化され、ディクショナリは {} を使用して初期化されます。 以前に DefaultArgument 属性を使用して Zero-Touch ノードのパラメータをマークし、someFunc([DefaultArgument("{0,1,2}")]) リスト構文を使用して特定のリストを既定として使用していた場合は、これは無効になり、リストに新しい初期化構文を使用するように DesignScript スニペットを変更する必要があります。

• 前述ように、パッケージに Dynamo の dll を含めて配布しないでください。(DynamoCore、DynamoServices など)

ノード モデル ノード 1.3 -> 2.0

ノード モデル ノードは、Dynamo 2.x に更新する際に多くの作業量を必要とするノードです。大まかに言うと、ノード タイプの新しいインスタンスのインスタンス化に使用される通常の nodeMode lコンストラクタに加えて、JSON からノードをロードするためにのみ使用されるコンストラクタを実装する必要があります。これらを区別するには、newtonsoft.Json.net の属性である [JsonConstructor] で、ロード時間コンストラクタをマークします。

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 から読み取ることができます。

これが nodeModel の JSON コンストラクタと非 JSON コンストラクタの主な違いです。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 UI ノードに対して複雑な元に戻す/やり直し機能を実装する場合は、これらのメソッドを実装し、これらのメソッドのパラメータとして提供されるXML ドキュメント オブジェクトにシリアル化する必要があります。これは、複雑な UI ノードを除いて、まれな使用事例です。

入力および出力ポート API

2.0 API の変更によって影響を受ける nodeModelノードでよく見られるのが、ノード コンストラクタでのポート登録です。Dynamo または DynamoSamples リポジトリ内のサンプルを確認すると、以前は、InPortData.Add() または OutPortData.Add() メソッドを使用していることがわかります。以前は、Dynamo API で InPortData および OutPortData パブリック プロパティが廃止とマークされていました。2.0 では、これらのプロパティは削除されました。開発者は、InPorts.Add() および OutPorts.Add() メソッドを使用する必要があります。また、これら 2 つの Add() メソッドには少し異なる要素があります。

InPortData.Add(new PortData("Port Name", "Port Description")); //Old version valid in 1.3 but now deprecated

vs

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

サンプル

1.3 UI ノードを Dynamo 2.x にアップグレードする方法について説明します。

この nodeModel クラスをロードして 2.0 で正しく保存するためにやるべきことは、ポートのロードを処理する jsonConstructor の追加です。単純にベース コンストラクタのポートを渡すだけであり、この実装は空です。

注: JsonConstructor で RegisterPorts() や類似のものを呼び出さないでください。ノード クラスの入力および出力パラメータ属性を使用し、新しいポートを構築します。コンストラクタに渡されたロード済みポートを使用したいため、これは望ましい結果ではありません。

以下に、UI ノードの複雑なコンストラクタを示します。

ファイルからこのノードをロードするための JSON コンストラクタを追加する場合は、このロジックの一部を再作成する必要があります。ただし、ポートの作成、レーシングの設定、またはファイルからロードできるプロパティの既定値を設定するコードは含んでいないことに注意してください。

JSON にシリアル化したその他のパブリック プロパティ(ButtonText、WindowText など)は、コンストラクタに明示的なパラメータとして追加されていないことに注意してください。これらは、それぞれのプロパティのセッターを使用して JSON.net によって自動的に設定されます。

Dynamo の開発事例をお探しの場合は、次のリソースを参照してください。

サンプル リポジトリ

これらのサンプルは、ユーザ独自のプロジェクトを開始するために使用できる Visual Studio テンプレートです。

• : 基本的な ZeroTouch ノードのテンプレートです。

  • 複数の出力を返す:

  • Dynamo のネイティブ ジオメトリ オブジェクトを使用する:

  • サンプル プロパティ(Query ノード):

• : 基本的な NodeModel ノードとビュー カスタマイズのテンプレートです。

  • 基本 NodeModel テンプレート:

    • ノード属性を定義する(入力/出力名、説明、タイプ):

    • 入力がない場合に null ノードを返す:

    • 関数呼び出しを作成:

  • 基本 NodeModel ビュー カスタマイズ テンプレート: 、、、

    • 要素を更新する必要があることを UI に警告する:

    • NodeModel をカスタマイズする:

    • スライダ属性を定義する:

    • スライダの相互作用ロジックを決定する:

• : ZeroTouch、カスタム UI、テスト、ビュー拡張機能のテンプレートです。

  • • 基本的なカスタム UI ノードを作成する:

    • ドロップダウン メニューを作成する:

  • • システムのテスト:

    • ZeroTouch テスト:

  • :

    • ジオメトリ レンダリングに影響を与えるノード IGraphicItem を実装するノードを含む、ZeroTouch ノードのサンプル:

    • IRenderPackage を使用してジオメトリを色付けする場合の ZeroTouch ノードのサンプル:

  • : MenuItem をクリックしたときに、モードレス ウィンドウを表示する IViewExtension の実装です。

• : NodeModel を使用した高度な Dynamo パッケージ開発用テンプレートです。

  • 基本的なサンプル:

  • ジオメトリ サンプル:

  • UI サンプル:

ケース スタディ

サードパーティの開発者は、プラットフォームの改良に多大な貢献をしており、その多くはオープン ソースとしても提供されています。次のプロジェクトは、Dynamoで実行できる機能の非常に優れたサンプルです。

Ladybug は、EnegyPlus 天候ファイル(epw)をロード、解析、および修正するための Python ライブラリです。

Honeybee は、昼光(RADIANCE)とエネルギー解析(EnergyPlus/OpenStudio)の結果を作成、実行、および視覚化する Python ライブラリです。

Bumblebee: Excel と Dynamo の相互運用性(GPL)のためのプラグインです。

Clockwork は、Revit に関連するアクティビティに加えて、リスト管理、算術演算、文字列操作、ジオメトリ操作(主に境界ボックス、メッシュ、平面、点、サーフェス、UV、ベクトル)、パネル作成などの目的のためのカスタム ノードのコレクションです。

Dynamo は、コミュニティの創造性と取り組みに依存しています。Dynamo チームは、貢献者が可能性を探り、アイデアをテストし、コミュニティに参加してフィードバックを求めることを奨励しています。技術革新を強く推奨する一方で、変更は Dynamo をより使いやすくし、このドキュメントで定義されたガイドラインを満たす場合にのみマージされます。有用性が狭い範囲に限られる変更や定義はマージされません。

プル リクエストに期待されること

Dynamo チームは、プル リクエストが次のガイドラインに従うことを期待してます。

• と に従っていること。

• 新しいフィーチャを追加するときに単位テストを含めるていること。

• バグを修正する場合は、現在の動作にどのような不具合があるかを示す単位テストを追加すること。

• 議論を 1 つの問題に集中させること。新しい指摘事項や関連トピックが出現した場合は、新しいリクエストを作成します。

また、以下にやってはいけない事項も示します。

• 大きななプル リクエストを作成する。リクエストの内容が大きくなる場合は、まず問題を提起して議論を開始します。これにより膨大な時間を費やす前に、方向性について合意することができます。

• 自分が書いたものではないコードをコミットする。Dynamo に追加するのに適していると思われるコードが見つかった場合は、処理を進める前に、問題を提起して議論を開始してください。

• ライセンス関連のファイルまたはヘッダを変更するプル リクエストを送信する。ライセンス関連に問題があると思われる場合は、問題を報告してください。まずは問題について話し合います。

• 問題の報告も議論もないまま API の追加を行うこと。

プル リクエスト テンプレートに入力する

プル リクエストを送信する場合は、を使用してください。プル リクエストを提出する前に、目的が明確に記述されていること、すべての宣言が真実であることを確認します。

• このプル リクエストの後、コードベースはより良い状態であること。

• に従って文書化されている。

• このプル リクエストに含まれるテストのレベルが適切である。

• ユーザ向けの文字列がある場合、*.resx ファイルに抽出されている。

• すべてのテストは、セルフサービス CI を使用して合格している。

• UI 変更のスナップショット(ある場合)。

• API に対する変更はに従っており、に文書化されている。

Dynamo チームによって、適切なレビュー担当者がプル リクエストに割り当てられます。

プル リクエストのレビュー プロセス

プル リクエストを送信したら、投稿者はレビュー プロセス中も引き続き関与する必要があります。次のレビュー基準にご留意ください。

• Dynamo チームでは月 1 回のミーティングを行い、古いものから新しいものの順にプル リクエストをレビューします。

• レビュー済みのプル リクエストで所有者による変更が必要な場合、所有者は 30 日以内に回答する必要があります。次回のミーティングまでに動きがなかった場合は、チームはプル リクエストを終了するか、その有用性に応じてチームの誰かが引き継ぎます。

• プル リクエストには、Dynamo の既定のプル リクエスト テンプレートを使用する必要があります。

• Dynamo プル リクエスト テンプレートが完全に記入される必要があり、すべての宣言が満たされていないプル リクエストはレビューされません。

Dynamo Revit コミットを厳選する

Revit には複数のバージョンが存在するため、Revit の異なるバージョンで新しい機能を利用できるように、特定の DynamoRevit リリース ブランチに特定の変更を選択する必要がある場合があります。レビュー プロセス中、貢献者は Dynamo チームの指定に従ってレビュー済みのコミットを他の DynamoRevit ブランチに厳選する責任があります。

パッケージをパブリッシュする

パッケージは、Dynamo コミュニティでノードを保存し、共有できる便利な方法です。パッケージには、Dynamo ワークスペースで作成されたカスタム ノードから NodeModel 派生ノードまで、すべての情報を含めることができます。パッケージは、Package Manager を使用してパブリッシュおよびインストールします。ここで説明する内容に加えて、 のパッケージに関する一般的なガイドも参照してください。

Package Manager について

Dynamo Package Manager は、Dynamo または Web ブラウザからアクセスできるソフトウェア レジストリ(npm と同様)です。Package Manager には、パッケージのインストール、パブリッシュ、更新、および表示が含まれます。npm と同様に、パッケージの異なるバージョンが維持されます。プロジェクトの依存関係を管理する場合にも役立ちます。

ブラウザでパッケージを検索し、統計情報を表示します:

• Dynamo では、Package Manager にはパッケージのインストール、パブリッシュ、および更新が含まれます。

1. パッケージをオンラインで検索する: Packages > Search for a Package...

2. インストールされたパッケージを表示/編集する: Packages > Manage Packages...

3. 新しいパッケージをパブリッシュする: Packages > Publish New Package...

パッケージをパブリッシュする

パッケージは、Dynamo 内の Package Manager からパブリッシュします。プロセスとしては、まずローカルにパブリッシュし、パッケージをテストしてから、オンラインでパブリッシュしてコミュニティと共有することが推奨されます。ここでは NodeModel ケース スタディを使用して、RectangularGrid ノードをパッケージとしてローカルにパブリッシュし、オンラインでパブリッシュする際に必要となる手順を紹介します。

Dynamo を起動して、Packages > Publish New Package... を選択し、Publish a Package ウィンドウを開きます。

1. Add file... を選択して、パッケージに追加するファイルを参照します。

2. NodeModel ケース スタディから、2 つの .dll ファイルを選択します。

3. Ok を選択します。

パッケージの内容にファイルを追加したら、パッケージに名前を付け、説明とバージョンを記入します。Dynamo を使用してパッケージをパブリッシュすると、自動的に pkg.json ファイルが作成されます。

パッケージをパブリッシュする準備が整いました。

1. 名前、説明、バージョンなど必要な情報を入力します。

2. [ローカルにパブリッシュ]をクリックして Dynamo のパッケージ フォルダ: AppData\Roaming\Dynamo\Dynamo Core\1.3\packages を選択し、Core でノードを使用できるようにしてパブリッシュを実行します。パッケージが共有できる状態になるまでは、常にローカルにパブリッシュします。

パッケージをパブリッシュすると、ノードは Dynamo ライブラリのカテゴリ CustomNodeModel の下で使用できるようになります。

1. 先ほど Dynamo ライブラリで作成したパッケージ

パッケージをオンラインでパブリッシュする準備ができたら、Package Manager を開いて Publish を選択し、続いて Publish Online を選択します。

1. Dynamo がパッケージをどのようにフォーマットしたかを確認するには、「CustomNodeModel」の右側にある 3 つの垂直ドットをクリックし、[ルート フォルダを表示]を選択します。

2. Publish を選択し、[Dynamo パッケージをパブリッシュ]ウィンドウで Publish Online を選択します。

3. パッケージを削除するには、Delete を選択します。

パッケージを更新する方法について

パッケージの更新プロセスは、パブリッシュと同様です。Package Manager を開いて、更新する必要のあるパッケージの Publish Version... を選択し、上位バージョンを指定します。

1. Publish Version を選択し、新しいファイルを使用してルート フォルダ内の既存のパッケージを更新します。次に、ローカルにパブリッシュするか、オンラインでパブリッシュするかを選択します。

Package Manager Web クライアント

Package Manager Web クライアントは、バージョン管理やダウンロード統計など、パッケージ データの検索および表示にのみ使用されます。

パッケージとしての拡張機能

概要

Dynamo 拡張機能は、通常の Dynamo ノード ライブラリと同様に、パッケージ マネージャに配置できます。インストールされたパッケージにビューの拡張機能が含まれている場合は、Dynamo をロードするとその拡張機能が実行時にロードされます。Dynamo コンソールで、拡張機能が正しくロードされていることを確認できます。

パッケージ構造

拡張パッケージの構造は、通常のパッケージと同じで次のようになっています。

既に拡張機能をビルドしたと仮定すると、(少なくとも) .NET アセンブリとマニフェスト ファイルがあります。アセンブリには、IViewExtension または IExtension を実装するクラスが含まれている必要があります。マニフェスト .XML ファイルによって、拡張機能を起動するために Dynamo でどのクラスがインスタンス化されるかが決まります。Package Manager が拡張機能を正しく見つけるために、マニフェスト ファイルはアセンブリの場所と名前に正確に対応している必要があります。

アセンブリ ファイルを bin フォルダに、マニフェスト ファイルを extra フォルダに配置します。追加のアセットをこのフォルダに配置することもできます。

マニフェスト .XML ファイルの例:

アップロードする

上記のようにサブフォルダを含むフォルダが作成されたら、パッケージ マネージャにプッシュ(アップロード)できます。現在、DynamoSandbox からパッケージをパブリッシュできないため、注意してください。つまり、Dynamo Revit を使用する必要があります。Dynamo Revit 内で [パッケージ] => [新しいパッケージをパブリッシュ]にナビゲートします。これにより、パッケージを関連付ける Autodesk Account にログインするよう求めるメッセージが表示されます。

ログインすると、パッケージをパブリッシュする通常のウィンドウが開くため、パッケージや拡張機能に関するすべての必須フィールドに入力します。非常に重要な追加の手順として、どのアセンブリ ファイルもノード ライブラリとしてマークされていないことを確認する必要があります。この確認を行うには、読み込んだファイル(上で作成したパッケージ フォルダ)を右クリックします。コンテキスト メニューが表示され、このオプションをオン(またはオフ)にできます。すべての拡張機能アセンブリをオフにする必要があります。

パブリッシュして公開する前に、常にローカルにパブリッシュして、すべてが正しく機能していることを確認する必要があります。この確認が完了したら、パブリッシュを選択して公開できます。

プルする

パッケージが正常にアップロードされたことを確認するには、パブリッシュの手順で指定した名前とキーワードを使用してパッケージを検索します。最後に注意する点として、同じ拡張機能を機能させる前に Dynamo を再起動する必要があります。通常、このような拡張機能では、Dynamo の起動時にパラメータの指定が必要です。

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 をビルドする場合にのみ DynamoRevit の前に Dynamo を手動でビルドする必要があります。これより新しいバージョンの DynamoRevit リポジトリでは、NuGet パッケージ マネージャを使用してビルドに必要な Dynamo の依存関係を取得します。DynamoRevit 2.x のビルドでは Dynamo を手動でプルする必要はありませんが、DynamoRevit addin を実際に実行するには別の場所にコア dlls が必要であるため、やはり Dynamo のプルおよびビルドが必要です。詳細については、「」を参照してください。

GitHub で DynamoRevit リポジトリを見つける

DynamoRevit プロジェクトのコードは、GitHub で、Dynamo のソース コードとは別のリポジトリにあります。このリポジトリには、Revit 固有のノードのソース ファイルと、Dynamo をロードする Revit アドインが含まれています。Revit の異なるバージョン(2016、2017、2018 など)の DynamoRevit のビルドは、リポジトリ内でブランチとして構成されています。

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 を使用してリポジトリをビルドする

1. restorepackages.bat を右クリックして、Run as administrator を選択します。

パッケージが正常に復元された場合は、最新のベータ版 NuGet パッケージを含む packages フォルダが src フォルダに追加されます。

1. 最新のベータ版 Dynamo NuGet パッケージ

パッケージが復元された状態で、src にある Visual Studio ソリューション ファイル DynamoRevit.All.sln を開き、ソリューションをビルドします。最初はビルドで AssemblySharedInfo.cs が見つからない場合があります。その場合は、ビルドを再実行するとこの問題が解決します。

1. Build > Build Solution を選択します。

2. 出力ウィンドウでビルドが正常に作成されたことを確認します。「===== Build: 13 succeeded, 0 failed, 0 up-to-date, 0 skipped =====」というメッセージが表示されるはずです。

Revit で DynamoRevit のローカル ビルドを実行する

C:\ProgramData\Autodesk\Revit\Addins\2023 にある Revit のアドイン フォルダに Dynamo.addin ファイルを作成します。あるバージョンの DynamoRevit が既にインストールされているため、新しいビルドを指定するように既存のファイルを編集するのみです。

• <Assembly>...</Assembly> 内で DynamoRevitDS.dll のファイル パスを指定します。

または、特定のアセンブリの代わりに、アドインでバージョン セレクタをロードできます。

• <Assembly>...</Assembly> ファイル パスを DynamoRevitVersionSelector.dll に設定します

• <FullClassName>...</FullClassName> で、上記のアセンブリ要素パスを使用して指したアセンブリからインスタンス化するクラスを指定します。このクラスが、アドインのエントリ ポイントになります。

さらに、Revit に付属している既存の Dynamo を削除する必要があります。これを行うには、C:\\Program Files\Autodesk\Revit 2023\AddIns で、Dynamo を含む 2 つのフォルダ(DynamoForRevit および DynamoPlayerForRevit)を削除します。削除できますが、元の Dynamo for Revit を復元する必要がある場合は別のフォルダにバックアップすることもできます。

次の手順では、Dynamo Core アセンブリのファイル パスを、DynamoRevit の bin フォルダ内の Dynamo.config ファイルに追加します。DynamoRevit は、アドインを Revit で開いたときに、これらのアセンブリをロードします。この config ファイルを使用すると、さまざまなバージョンの Dynamo Core に DynamoRevit アドインを指定することができ、開発と変更のテストを Core と DynamoRevit の両方で実施できます。

コードは次のようになります。

• bin フォルダのフォルダ パスを <add key/> に追加します

このコードが DynamoRevit で適切に動作するように、この手順の前に Dynamo のクローンを作成してビルドしました。フォルダ パスはこのビルドを指します。

Revit を開くと、[管理]タブに Dynamo アドインがあるはずです。

1. Manage を選択します。

2. Dynamo アドインのアイコンをクリックします。

3. DynamoRevit のインスタンス

エラー ダイアログ ウィンドウにアセンブリが見つからないと表示される場合は、構築された DynamoCore のバージョンと実行時にロードするバージョンが一致していない可能性があります。たとえば、DynamoCore の最新の 2.0 ベータ版パッケージに対応する DynamoRevit は、Dynamo 1.3 dll を使用して起動しようとしても動作しません。両方のリポジトリが同じバージョンであり、DynamoRevit が一致するバージョンの NuGet 依存関係をプルしていることを確認します。これらは、DynamoRevit リポジトリの package.json ファイルで定義されています。

Visual Studio を使用して DynamoRevit をデバッグする

前のセクション「ソースから Dynamo をビルドする」では、Visual Studio でのデバッグと、プロセスに Visual Studio をアタッチする方法について簡単に説明しました。例として、Wall.ByCurveAndHeight ノードの例外を使用して、プロセスへのアタッチ、ブレーク ポイントの設定、コードのステップ実行、およびコール スタックを使用した例外のソースの決定方法について説明します。これらのデバッグ ツールは、一般的に .net 開発ワークフローに適用され、このガイド以外でも役立ちます。

• ブレーク ポイントをソース コード内の行に設定すると、アプリケーションがその行を実行する前に一時停止します。ノードが原因で DynamoRevit がクラッシュしたり、予期しない結果が返された場合は、ノードのソースにブレーク ポイントを追加してプロセスを一時停止し、コードにステップ インして、問題の原因が見つかるまで実行中の変数の値を検査できます

• コードをステップ実行すると、ソースを 1 行ずつ確認できます。関数を 1 つずつ実行したり、関数呼び出しにステップ インしたり、現在実行中の関数から抜けることができます。

• コール スタックでは、プロセスが現在実行している関数が表示され、この関数呼び出しを起動したそれまでの関数呼び出しも表示されます。Visual Studio には、これを表示するコール スタック ウィンドウがあります。たとえば、ソース コードの範囲外で例外に達した場合には、コール スタックに呼び出しコードへのパスが表示されます。

Wall.ByCurveAndHeight ノードは、curve 入力として PolyCurve を指定すると例外をスローし、「To BSPlineCurve が実装されていません」というメッセージが表示されます。デバッグを使用すると、ノードがこのジオメトリ タイプを曲線パラメータの入力として受け取らない理由が正確にわかります。この例では、DynamoRevit が正常にビルドされ、Revit のアドインとして実行できるものとします。

1. 例外をスローしている Wall.ByCurveAndHeight ノード

最初にソリューション ファイル DynamoRevit.All.sln を開き、Revit を起動して、DynamoRevit アドインを起動します。次に、Attach to Process ウィンドウで Revit プロセスに Visual Studio をアタッチします。

使用可能なプロセスとして表示するには、Revit と DynamoRevit を実行している必要があります。

1. Debug > Attach to Process... を選択して Attach to Process ウィンドウを開きます。

2. Transport を Default に設定します。

3. Revit.exe を選択します。

4. Attach を選択します。

Visual Studio を Revit にアタッチした状態で、Wall.cs にある Wall.ByCurveAndHeight ソース コードを開きます。これは、ファイルの Public static constructors 領域の Libraries > RevitNodes > Elements の下にある Solution Explorer で見つけることができます。壁タイプのコンストラクタでブレーク ポイントを設定します。これにより、Dynamo でノードを実行したときにプロセスが中断され、コードの各行を個別にステップ実行できます。通常、Dynamo の Zero Touch タイプのコンストラクタは、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 はクラッシュしませんでした。デバッグ プロセスによって、ソース コード内の別のメソッドが表示されて、問題のコンテキストがわかりました。

1. Walls.cs で例外が発生するステートメントにヒットした際に、デバッグ プロセスにより、ProtoToRevitCurve.cs 内のユーザ コードで問題の原因を詳しく調べることができます。

2. ProtoToRevitCurve.cs 内の例外が発生するステートメント。

3. コール スタックで、例外がユーザ　コード以外から発生していることが確認できます。

4. 例外に関する情報を表示するポップアップ ウィンドウ。

このプロセスは、作業中のソース ファイルに適用できます。Dynamo Studio 用の Zero-Touch ノードのライブラリを開発している場合は、ライブラリのソースを開いて Dynamo プロセスをアタッチするとノード ライブラリをデバッグできます。すべてが完全に機能していても、デバッグは、コードを調べて動作の仕組みを理解するのに最適な方法です。

最新ビルドをプルする

このプロセスは、Dynamo の変更をプルするプロセスとほとんど同じですが、正しいブランチにいることを確認する必要があります。DynamoRevit リポジトリで git branch コマンドを使用して、ローカルで使用可能なブランチと現在チェック アウトされているブランチを確認します。

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 ブランチから変更をプルします。

「origin」は単にクローンの作成元の URL を指しています。

ここでは、現在どのブランチにいるか、またどのブランチからプルするかに注意し、たとえば、RC2.13.1_Revit2023 から Revit2018 に変更をプルしないようにします。

「ソースから Dynamo をビルドする」で説明したように、DynamoRevit リポジトリに対する変更を送信できる場合は、「プル リクエスト」セクションに記載されている Dynamo チームのガイドラインに従って、プル リクエストを作成できます。

はじめに

このセクションでは、グラフ、パッケージ、ライブラリを Dynamo 3.x に移行する際、発生する可能性のある問題について説明します。

Dynamo 3.0 は主要なリリースであり、いくつかの API が変更または削除されました。Dynamo 3.x の開発者やユーザーに影響する可能性のある最も大きな変更は、.NET8 への移行です。

Dotnet/.NET は、Dynamo の記述言語である C# 言語をサポートするランタイムです。このランタイムが、オートデスクのエコシステムの他の部分とともに最新バージョンに更新されました。

詳細については、ブログの投稿を参照してください。

パッケージの互換性

Dynamo 3.x で Dynamo 2.x パッケージを使用する

Dynamo 3.x は .NET8 ランタイムで実行されるようになったため、Dynamo 2.x 用に作成されたパッケージ(.NET48 を使用)の Dynamo 3.x での動作は保証されていません。3.0 より前の Dynamo バージョンからパブリッシュされたパッケージを Dynamo 3.x でダウンロードしようとすると、パッケージが旧バージョンの Dynamo からパブリッシュされたという警告が表示されます。

これは、パッケージが機能しないということではありません。 単に互換性の問題が発生する可能性があるという警告です。通常は、Dynamo 3.x 専用に作成された新しいバージョンがあるかどうかを確認することをお勧めします。

パッケージを読み込む際にも Dynamo ログ ファイルでこのような警告が表示されることがあります。すべてが正しく動作している場合は、警告を無視することができます。

Dynamo 2.x で Dynamo 3.x パッケージを使用する

Dynamo 3.x 用に作成されたパッケージ(.Net8 を使用)が Dynamo 2.x で動作することはほとんどありません。また、旧バージョンを使用しているときに Dynamo の新しいバージョン用に作成されたパッケージをダウンロードする際にも警告が表示されます。