Die DynamoRevit-Quelldateien werden auch im DynamoDS-GitHub gehostet, damit Entwickler Beiträge einbringen und Beta-Versionen erstellen können. Die Erstellung von DynamoRevit aus Quelldateien folgt im Allgemeinen dem gleichen Prozess wie bei Dynamo, mit Ausnahme einiger wichtiger Details:
DynamoRevit referenziert Dynamo-Assemblys. Diese sollten daher mit entsprechenden NuGet-Paketen erstellt werden. DynamoRevit 2.x lässt sich beispielsweise nicht in Dynamo 1.3 laden.
DynamoRevit ist für bestimmte Revit-Versionen spezifisch. Beispiel: Die Verzweigung DynamoRevit 2018 muss unter Revit 2018 ausgeführt werden.
In diesem Handbuch verwenden wir folgende Versionen:
Revit 2023
Den neuesten DynamoRevit-Build in der Verzweigung Revit2023
Den neuesten Dynamo-Build
Um einen erfolgreichen Build zu gewährleisten, werden sowohl das Dynamo- als auch das DynamoRevit-Repository, die für diese exemplarische Vorgehensweise verwendet werden, geklont und erstellt.
Anmerkung: Die manuelle Erstellung von Dynamo vor DynamoRevit ist nur erforderlich, wenn Sie Dynamo 1.x und DynamoRevit 1.x erstellen. Neuere Versionen des DynamoRevit-Repositorys basieren auf dem NuGet-Paket-Manager für die zum Erstellen erforderlichen Dynamo-Abhängigkeiten. Auch wenn beim Build Dynamo Revit 2.x kein manueller Abruf von Dynamo erforderlich ist, benötigen Sie die dlls
-Kerndateien dennoch an anderer Stelle, um das Dynamo Revit-addin
auszuführen. Es lohnt sich also, Dynamo dennoch abzurufen und zu erstellen. Weitere Informationen finden Sie unten: Erstellen des Repositorys mit Visual Studio
Der Code für das DynamoRevit-Projekt befindet sich in einem separaten Repository auf GitHub, nicht in dem Repository, in dem sich der Dynamo-Kernquellcode befindet. Dieses Repository enthält die Quelldateien für Revit-spezifische Blöcke und das Revit-Zusatzmodul, das Dynamo lädt. Builds von DynamoRevit für verschiedene Versionen von Revit (z. B. 2016, 2017 oder 2018) sind im Repository als Verzweigungen angeordnet.
Die DynamoRevit-Quelldateien befinden sich hier: https://github.com/DynamoDS/DynamoRevit.
Klonen oder laden Sie das Repository herunter.
Die DynamoRevit-Verzweigungen referenzieren Revit-Versionen.
Ähnlich wie beim Abrufen des Dynamo-Repositorys verwenden wir den Git-Befehl zum Klonen, um DynamoRevit zu klonen und die Verzweigung anzugeben, die unserer Revit-Version entspricht. Zunächst öffnen wir eine Befehlszeilenschnittstelle und legen das aktuelle Verzeichnis auf den Speicherort fest, an den wir die Dateien klonen möchten.
cd C:\Users\username\Documents\GitHub
ändert das aktuelle Verzeichnis.
Ersetzen Sie
username
durch Ihren Benutzernamen.
Jetzt können wir das Repository in dieses Verzeichnis klonen. Wir müssen eine Verzweigung des Repositorys angeben. Wir können jedoch nach dem Klonen zu dieser Verzweigung wechseln.
git clone https://github.com/DynamoDS/DynamoRevit.git
klont das Repository von einer Remote-URL und wechselt vorgabemäßig zur Hauptverzweigung.
Nachdem das Klonen des Repositorys abgeschlossen ist, ändern Sie das aktuelle Verzeichnis in den Repository-Ordner, und wechseln Sie zu der Verzweigung, die der installierten Version von Revit entspricht. In diesem Beispiel wird Revit RC2.13.1_Revit2023 verwendet. Alle Remote-Verzweigungen können auf der GitHub-Seite im Dropdown-Menü Branch angezeigt werden.
cd C:\Users\username\Documents\GitHub\DynamoRevit
ändert das Verzeichnis in DynamoRevit.
git checkout RC2.13.1_Revit2023
setzt die aktuelle Verzweigung auf RC2.13.1_Revit2023
.
git branch
überprüft, in welcher Verzweigung wir uns befinden, und zeigt die anderen Verzweigungen an, die lokal verfügbar sind.
Die Verzweigung mit einem Sternchen ist die derzeit ausgecheckte Verzweigung. Die Verzweigung
Revit2018
wird angezeigt, da wir diese zuvor ausgecheckt haben, sodass sie lokal verfügbar ist.
Es ist wichtig, die richtige Verzweigung des Repositorys zu wählen, um sicherzustellen, dass beim Erstellen des Projekts in Visual Studio Assemblys in der richtigen Version des Revit-Installationsverzeichnisses referenziert werden, insbesondere RevitAPI.dll
und RevitAPIUI.dll
.
Bevor wir das Repository erstellen, müssen wir die NuGet-Pakete mit der Datei restorepackages.bat
im Ordner src
wiederherstellen. Diese BAT-Datei verwendet den NuGet-Paket-Manager, um die für DynamoRevit erforderlichen, erstellten Binärdateien von Dynamo Core abzurufen. Sie können diese auch manuell erstellen, aber nur, wenn Sie nur Änderungen an DynamoRevit und nicht an Dynamo Core vornehmen. So können Sie schneller durchstarten. Führen Sie diese Datei als Administrator aus.
Klicken Sie mit der rechten Maustaste auf
restorepackages.bat
, und wählen SieRun as administrator
.
Wenn die Pakete erfolgreich wiederhergestellt wurden, wird ein packages
-Ordner mit den neuesten NuGet-Beta-Paketen zum Ordner src
hinzugefügt.
Die neuesten Dynamo-NuGet-Beta-Pakete
Nachdem die Pakete wiederhergestellt wurden, öffnen Sie die Visual Studio-Projektmappendatei DynamoRevit.All.sln
in src
, und erstellen Sie die Projektmappe. Der Build kann AssemblySharedInfo.cs
möglicherweise zunächst nicht finden. Wenn dies der Fall ist, kann dieses Problem durch erneutes Ausführen des Builds behoben werden.
Wählen Sie
Build > Build Solution
aus.Überprüfen Sie im Ausgabefenster, ob die Erstellung erfolgreich war. Es sollte eine Meldung ähnlich der folgenden angezeigt werden:
===== Build: 13 succeeded, 0 failed, 0 up-to-date, 0 skipped =====
.
Revit benötigt eine Zusatzmoduldatei, um DynamoRevit zu erkennen. Diese würde vom Installationsprogramm automatisch erstellt. In der Entwicklung müssen wir manuell eine Zusatzmoduldatei erstellen, die auf den gewünschten Build von DynamoRevit verweist, insbesondere auf die Assembly DynamoRevitDS.dll
. Außerdem müssen wir DynamoRevit auf einen Dynamo-Build verweisen.
Erstellen Sie eine Dynamo.addin
-Datei im Zusatzmodulordner von Revit, der sich unter C:\ProgramData\Autodesk\Revit\Addins\2023
befindet. Wir haben bereits eine Version von DynamoRevit installiert, daher bearbeiten wir einfach die vorhandene Datei, um auf den neuen Build zu verweisen.
Geben Sie den Dateipfad von DynamoRevitDS.dll
in <Assembly>...</Assembly>
an.
Alternativ können wir auch festlegen, dass das Zusatzmodul die Versionsauswahl anstelle einer bestimmten Assembly lädt.
Legen Sie den Dateipfad für <Assembly>...</Assembly>
auf DynamoRevitVersionSelector.dll
fest.
<FullClassName>...</FullClassName>
gibt an, welche Klasse aus der Assembly instanziiert werden soll, auf die mit dem oben angegebenen Assembly-Elementpfad verwiesen wurde. Diese Klasse wird als Einstiegspunkt für das Zusatzmodul verwendet.
Außerdem müssen wir die vorhandene Dynamo-Version entfernen, die im Lieferumfang von Revit enthalten ist. Wechseln Sie dazu zu C:\\Program Files\Autodesk\Revit 2023\AddIns
, und entfernen Sie die beiden Ordner, die Dynamo enthalten: DynamoForRevit
und DynamoPlayerForRevit
. Sie können sie entweder löschen oder in einem separaten Ordner sichern, wenn Sie die Originalversion von Dynamo for Revit wiederherstellen müssen.
Der zweite Schritt besteht darin, einen Dateipfad für die Dynamo Core-Assemblys zur Datei Dynamo.config
im Ordner bin
von DynamoRevit hinzuzufügen. DynamoRevit lädt diese, wenn das Zusatzmodul in Revit geöffnet wird. In dieser Konfigurationsdatei können Sie Ihr DynamoRevit-Zusatzmodul auf verschiedene Versionen von Dynamo Core verweisen, um Änderungen sowohl in Core als auch in DynamoRevit zu entwickeln und zu testen.
Der Code sollte wie folgt aussehen:
Fügen Sie den Verzeichnispfad des Ordners bin
zu <add key/>
hinzu.
Wir haben Dynamo direkt vor dieser exemplarischen Vorgehensweise geklont und erstellt, um sicherzustellen, dass Dynamo gut mit DynamoRevit funktioniert. Der Verzeichnispfad verweist auf diesen Build.
Wenn wir jetzt Revit öffnen, sollte sich auf der Registerkarte Verwalten ein Dynamo-Zusatzmodul befinden.
Wählen Sie
Manage
aus.Klicken Sie auf das Symbol für das Dynamo-Zusatzmodul.
Eine Instanz von DynamoRevit.
Wenn ein Fehler-Dialogfeld mit fehlenden Assemblys angezeigt wird, ist es wahrscheinlich, dass ein Konflikt zwischen den von Ihnen erstellten Versionen von DynamoCore und den Versionen, die Sie zur Laufzeit laden, aufgetreten ist. Beispiel: DynamoRevit mit den neuesten 2.0-Beta-Paketen von DynamoCore funktioniert nicht, wenn Sie versuchen, die Anwendung mit Dynamo 1.3-DLL-Dateien zu starten. Stellen Sie sicher, dass beide Repositorys dieselbe Version aufweisen und DynamoRevit eine übereinstimmende Version der NutGet-Abhängigkeiten abruft. Diese werden in der Datei package.json
des DynamoRevit-Repositorys definiert.
Im vorherigen Abschnitt Erstellen von Dynamo aus Quelldateien haben wir das Debugging in Visual Studio kurz vorgestellt und beschrieben, wie Visual Studio an einen Prozess angehängt werden kann. Anhand einer Beispielausnahme im Block Wall.ByCurveAndHeight werden Sie durch das Anhängen an einen Prozess, das Festlegen von Haltepunkten, das Durchgehen durch Code und das Ermitteln der Quelle der Ausnahme mithilfe der Aufrufliste geführt. Diese Debugging-Werkzeuge gelten generell für .NET-Entwicklungsarbeitsabläufe. Daher ist es sinnvoll, sich außerhalb dieses Handbuchs eingehender mit diesen zu beschäftigen.
An den Prozess anhängen: Hierbei wird eine laufende Anwendung zum Debuggen mit Visual Studio verknüpft. Wenn wir für das Verhalten in einem Build von DynamoRevit ein Debugging durchführen möchten, können wir die DynamoRevit-Quelldateien in Visual Studio öffnen und den Revit.exe
-Prozess anhängen. Dies ist der übergeordnete Prozess des DynamoRevit-Zusatzmoduls. Visual Studio verwendet eine Symboldatei (.pbd
), um die Verbindung zwischen den Assemblys, die DynamoRevit ausführt, und dem Quellcode herzustellen.
Haltepunkte definieren im Quellcode Zeilen, an denen die Anwendung vor dem Ausführen angehalten wird. Wenn ein Block einen Absturz von DynamoRevit verursacht oder ein unerwartetes Ergebnis zurückgibt, können wir einen Haltepunkt zur Quelle des Blocks hinzufügen, um den Vorgang anzuhalten, den Code einzusehen und die Live-Werte der Variablen zu überprüfen, bis wir die Ursache des Problems gefunden haben.
Code durchgehen: Hierbei wird die Quelle Zeile für Zeile durchlaufen. Wir können Funktionen nacheinander ausführen, einen Funktionsaufruf schrittweise ausführen oder die gerade ausgeführte Funktion verlassen.
Die Aufrufliste zeigt die Funktion an, die derzeit von einem Prozess ausgeführt wird, im Vergleich zu den vorherigen Funktionsaufrufen, die diesen Funktionsaufruf veranlasst haben. Visual Studio verfügt über ein Aufruflistenfenster, um dies anzuzeigen. Wenn wir beispielsweise eine Ausnahme außerhalb des Quellcodes erreichen, können wir den Pfad zum aufrufenden Code in der Aufrufliste sehen.
Im Artikel 2,000 Things You Should Know About C# erhalten Sie eine ausführlichere Erläuterung zu Aufruflisten.
Der Block Wall.ByCurveAndHeight gibt eine Ausnahme mit der folgenden Meldung aus, wenn er eine PolyCurve als Kurveneingabe erhält: To BSPlineCurve Not Implemented. Durch das Debugging können wir herausfinden, warum genau der Block diesen Geometrietyp nicht als Eingabe für den Kurvenparameter akzeptiert. In diesem Beispiel wird davon ausgegangen, dass DynamoRevit erfolgreich erstellt wurde und als Zusatzmodul für Revit ausgeführt werden kann.
Der Block Wall.ByCurveAndHeight löst eine Ausnahme aus.
Öffnen Sie zunächst die Projektmappendatei DynamoRevit.All.sln
, starten Sie Revit, und starten Sie dann das DynamoRevit-Zusatzmodul. Hängen Sie anschließend im Fenster Attach to Process
Visual Studio an den Revit-Prozess an.
Revit und DynamoRevit müssen ausgeführt werden, um als verfügbare Prozesse angezeigt zu werden.
Öffnen Sie das Fenster
Attach to Process
durch Auswahl vonDebug > Attach to Process...
.Legen Sie
Transport
aufDefault
fest.Wählen Sie
Revit.exe
aus.Wählen Sie
Attach
aus.
Wenn Visual Studio an Revit angehängt ist, öffnen Sie den Wall.ByCurveAndHeight-Quellcode in Wall.cs
. Wir finden diesen im Projektmappen-Explorer unter Libraries > RevitNodes > Elements
im Bereich Public static constructors
der Datei. Legen Sie im Konstruktor des Wandtyps einen Haltepunkt fest, sodass bei Ausführung eines Blocks in Dynamo der Prozess unterbrochen wird und wir die Codezeilen einzeln durchgehen können. Normalerweise beginnen Dynamo-Konstruktoren vom Typ Zero-Touch mit By<parameters>
.
Die Klassendatei mit dem Konstruktor für Wall.ByCurveAndHeight.
Legen Sie einen Haltepunkt fest, indem Sie entweder links neben die Zeilennummer klicken oder mit der rechten Maustaste auf die Codezeile klicken und
Breakpoint > Insert Breakpoint
auswählen.
Nachdem der Haltepunkt festgelegt wurde, muss der Prozess durch die Funktion Wall.ByCurveAndHeight laufen. Die Funktion kann in Dynamo erneut ausgeführt werden, indem erneut eine Verbindung mit einem der Anschlüsse hergestellt wird. Dadurch wird eine erneute Ausführung des Blocks erzwungen. Der Haltepunkt wird in Visual Studio erreicht.
Das Symbol für den Haltepunkt ändert sich, wenn er erreicht wird.
Das Fenster mit der Aufrufliste zeigt die als Nächstes angewendete Methode.
Überspringen Sie nun die einzelnen Zeilen im Konstruktor, bis die Ausnahme erreicht wird. Der gelb hervorgehobene Code ist die nächste auszuführende Anweisung.
Die Debugging-Werkzeuge für die Navigation im Code.
Drücken Sie
Step Over
, um den markierten Code auszuführen, und unterbrechen Sie dann die Ausführung, nachdem die Funktion zurückgegeben wurde.Die nächste auszuführende Anweisung, angegeben durch die gelbe Hervorhebung und den Pfeil.
Wenn wir weiter durch die Funktion gehen, erreichen wir die Ausnahme, die im DynamoRevit-Fenster angezeigt wird. Im Fenster mit der Aufrufliste können wir sehen, dass die Ausnahme ursprünglich von einer Methode mit dem Namen Autodesk.Revit.CurveAPIUtils.CreateNurbsCurve
ausgelöst wurde. Glücklicherweise wird die Ausnahme hier verarbeitet, sodass Dynamo nicht abgestürzt ist. Der Debugging-Prozess hat den Kontext für das Problem zugänglich gemacht, indem eine andere Methode im Quellcode ermittelt wurde.
Da dies keine Open-Source-Bibliothek ist, können wir dort keine Änderungen vornehmen. Jetzt, da wir über weitere Informationen verfügen, können wir das Problem mit mehr Kontext melden, indem wir eine GitHub-Anfrage übermitteln. Oder wir können eine Lösung für dieses Problem vorschlagen, indem wir eine Pull-Anforderung stellen.
Wenn wir in
Walls.cs
auf die Anweisung treffen, die die Ausnahme verursacht, gelangen wir durch den Debugging-Prozess so nah wie möglich an die Ursache des Problems im Benutzercode inProtoToRevitCurve.cs
.Die Anweisung, die die Ausnahme in
ProtoToRevitCurve.cs
verursacht.In der Aufrufliste sehen wir, dass die Ausnahme aus Nichtbenutzercode stammt.
Ein Popup-Fenster mit Informationen zur Ausnahme.
Dieser Vorgang kann auf alle Quelldateien angewendet werden, mit denen wir arbeiten. Wenn wir eine Bibliothek mit Zero-Touch-Blöcken für Dynamo Studio entwickeln, können wir die Quelle der Bibliothek öffnen und einen Dynamo-Prozess anhängen, um für die Blockbibliothek ein Debugging durchzuführen. Auch wenn alles perfekt funktioniert, ist das Debugging eine gute Möglichkeit, Code zu prüfen und herauszufinden, wie bestimmte Aspekte funktionieren.
Dieser Vorgang ist fast identisch mit dem Abrufen von Änderungen für Dynamo, mit der Ausnahme, dass wir sicherstellen müssen, dass wir uns in der richtigen Verzweigung befinden. Verwenden Sie den Befehl git branch
im DynamoRevit-Repository, um zu sehen, welche Verzweigungen lokal verfügbar und welche derzeit ausgecheckt sind.
cd C:\Users\username\Documents\GitHub\DynamoRevit
legt das aktuelle Verzeichnis auf das DynamoRevit-Repository fest.
git branch
überprüft, ob wir uns in der richtigen Verzweigung, RC2.13.1_Revit2023
, befinden.
git pull origin RC2.13.1_Revit2023
ruft Änderungen aus der Remote-Ursprungsverzweigung RC2.13.1_Revit2023
ab.
Der Ursprung verweist einfach auf die ursprüngliche URL, die wir geklont haben.
Wir sollten hier sorgsam darauf achten, in welcher Verzweigung wir uns gerade befinden und von welcher Verzweigung wir Daten abrufen, um zu vermeiden, dass Änderungen beispielsweise von
RC2.13.1_Revit2023
inRevit2018
abgerufen werden.
Wie unter Erstellen von Dynamo aus Quelldateien erwähnt, können wir eine Pull-Anforderung erstellen, wenn wir bereit sind, eine Änderung an das DynamoRevit-Repository zu übermitteln. Dabei folgen wir den Richtlinien des Dynamo-Teams, die im Abschnitt zu Pull-Anforderungen beschrieben werden.
Die Quelldateien von Dynamo werden auf GitHub gehostet, sodass jeder sie klonen und dazu beitragen kann. In diesem Kapitel erfahren Sie, wie Sie das Repository mithilfe von Git klonen, die Quelldateien mit Visual Studio kompilieren, einen lokalen Build ausführen und ein Debugging für diesen durchführen sowie neue Änderungen aus GitHub abrufen.
GitHub ist ein Hosting-Dienst, der auf Git, einem Versionskontrollsystem zur Änderungsverfolgung und Koordination der Arbeit zwischen verschiedenen Personen, basiert. Git ist ein Werkzeug, mit dem wir die Quelldateien von Dynamo herunterladen und mit ein paar Befehlen auf dem neuesten Stand halten können. Mit dieser Methode vermeiden wir die unnötige und von Natur aus unübersichtliche Arbeit des Herunterladens und manuellen Ersetzens der Quelldateien bei jedem Update. Das Git-Versionskontrollsystem verfolgt alle Unterschiede zwischen einem lokalen und einem Remote-Code-Repository.
Die Quelldateien von Dynamo werden im DynamoDS-GitHub im folgenden Repository gehostet: https://github.com/DynamoDS/Dynamo.
Dynamo-Quelldateien
Klonen oder laden Sie das gesamte Repository herunter.
Zeigen Sie andere DynamoDS-Repositorys an.
Dynamo-Quelldateien
Git-spezifische Dateien
Bevor wir das Repository klonen können, müssen wir Git installieren. Befolgen Sie diese Kurzanleitung, um die Installationsschritte auszuführen und zu erfahren, wie Sie einen GitHub-Benutzernamen und eine -E-Mail-Adresse einrichten. In diesem Beispiel verwenden wir Git in der Befehlszeile. In diesem Handbuch wird davon ausgegangen, dass Sie Windows verwenden. Sie können Git jedoch auch unter Mac oder Linux verwenden, um die Dynamo-Quelle zu klonen.
Wir benötigen eine URL für das Dynamo-Repository, von dem geklont werden soll. Sie finden diese auf der Repository-Seite unter der Schaltfläche Clone or Download. Kopieren Sie die URL zum Einfügen in die Befehlszeile.
Wählen Sie Clone or Download aus.
Kopieren Sie die URL.
Wenn Git installiert ist, können wir das Dynamo-Repository klonen. Öffnen Sie zunächst die Eingabeaufforderung. Navigieren Sie dann unter Verwendung des Befehls zum Ändern des Verzeichnisses cd
zu dem Ordner, in den die Quelldateien geklont werden sollen. In diesem Fall haben wir unter Documents
einen Ordner mit dem Namen Github
erstellt.
cd C:\Users\username\Documents\GitHub
Ersetzen Sie username durch Ihren Benutzernamen.
Im nächsten Schritt führen wir einen Git-Befehl aus, um das Dynamo-Repository an den angegebenen Speicherort zu klonen. Die URL im Befehl wird durch Klicken auf die Schaltfläche Clone or Download auf GitHub abgerufen. Führen Sie diesen Befehl im Befehlsterminal aus. Beachten Sie, dass dadurch die Hauptverzweigung für das Dynamo-Repository geklont wird, bei der es sich um den aktuellen Code für Dynamo handelt und der die neueste Version von Dynamo-Code enthält. Diese Verzweigung ändert sich täglich.
git clone https://github.com/DynamoDS/Dynamo.git
Wir wissen, dass Git funktioniert, wenn der Klonvorgang erfolgreich abgeschlossen wurde. Navigieren Sie im Datei-Explorer zu dem Verzeichnis, in das Sie die Quelldateien geklont haben, um sie anzuzeigen. Die Verzeichnisstruktur sollte der Hauptverzweigung des Dynamo-Repositorys auf GitHub entsprechen.
Dynamo-Quelldateien
Git-Dateien
Nachdem die Quelldateien nun auf den lokalen Computer geklont wurden, können wir eine ausführbare Datei für Dynamo erstellen. Dazu müssen wir die Visual Studio-IDE einrichten und sicherstellen, dass .NET Framework und DirectX installiert sind.
Laden Sie die kostenlose, voll funktionsfähige IDE (Integrated Development Environment, integrierte Entwicklungsumgebung) Microsoft Visual Studio Community 2015 herunter, und installieren Sie sie (spätere Versionen funktionieren möglicherweise ebenfalls).
Laden Sie Microsoft .NET Framework 4.5 oder höher herunter, und installieren Sie die Software.
Installieren Sie Microsoft DirectX aus dem lokalen Dynamo-Repository (Dynamo\tools\install\Extra\DirectX\DXSETUP.exe
).
.NET und DirectX sind möglicherweise bereits installiert.
Sobald die Installation abgeschlossen ist, können wir Visual Studio starten und die Projektmappe Dynamo.All.sln
unter Dynamo\src
öffnen.
Wählen Sie
File > Open > Project/Solution
aus.Navigieren Sie zum Dynamo-Repository, und öffnen Sie den Ordner
src
.Wählen Sie die Projektmappendatei
Dynamo.All.sln
aus.Wählen Sie
Open
aus.
Bevor wir die Projektmappe erstellen können, müssen einige Einstellungen angegeben werden. Zunächst sollten wir eine Debugversion von Dynamo erstellen, damit Visual Studio während des Debugging weitere Informationen sammeln kann, um uns bei der Entwicklung zu unterstützen. Außerdem sollten wir AnyCPU als Ziel verwenden.
Diese werden zu Ordnern im Ordner
bin
.
In diesem Beispiel haben wir
Debug
als Projektmappenkonfiguration gewählt.Setzen Sie die Projektmappenplattform auf
Any CPU
.
Wenn das Projekt geöffnet ist, können wir die Projektmappe erstellen. Durch diesen Vorgang wird eine DynamoSandbox.exe-Datei erstellt, die ausgeführt werden kann.
Durch das Erstellen des Projekts werden NuGet-Abhängigkeiten wiederhergestellt.
Wählen Sie
Build > Build Solution
aus.Stellen Sie im Ausgabefenster sicher, dass der Build erfolgreich war. Er sollte in etwa wie folgt lauten:
==== Build: 69 succeeded, 0 failed, 0 up-to-date, 0 skipped ====
Wenn Dynamo erfolgreich erstellt wurde, wird im Dynamo-Repository ein Ordner namens bin
mit der Datei DynamoSandbox.exe erstellt. In unserem Fall verwenden wir die Option Debug für die Erstellung, sodass sich die ausführbare Datei unter bin\AnyCPU\Debug
befindet. Durch Ausführen dieser Datei wird ein lokaler Build von Dynamo geöffnet.
Die ausführbare DynamoSandbox-Datei, die wir gerade erstellt haben. Führen Sie diese Datei aus, um Dynamo zu starten.
Damit sind wir fast bereit, um mit der Entwicklung für Dynamo zu beginnen.
Anweisungen zum Erstellen von Dynamo für andere Plattformen (z. B. Linux oder OS X) finden Sie auf dieser Wiki-Seite.
Beim Debuggen werden Fehler oder Probleme identifiziert, isoliert und behoben. Nachdem Dynamo erfolgreich aus den Quelldateien erstellt wurde, können wir verschiedene Werkzeuge in Visual Studio verwenden, um das Debugging für eine laufende Anwendung, z. B. das DynamoRevit-Zusatzmodul, durchzuführen. Wir können den Quellcode analysieren, um die Ursache eines Problems zu finden, oder den derzeit ausgeführten Code überwachen. Eine ausführlichere Beschreibung des Debugging und der Navigation durch Code in Visual Studio finden Sie in den Visual Studio-Dokumenten.
Für die eigenständige Dynamo-Anwendung DynamoSandbox werden zwei Optionen für das Debugging behandelt:
Erstellen und Starten von Dynamo direkt über Visual Studio
Anhängen von Visual Studio an einen laufenden Dynamo-Prozess
Durch Starten von Dynamo über Visual Studio wird die Projektmappe ggf. für jede Debugging-Sitzung neu erstellt. Wenn wir also Änderungen an den Quelldateien vorgenommen haben, werden diese beim Debuggen berücksichtigt. Lassen Sie die Projektmappe Dynamo.All.sln
geöffnet, wählen Sie Debug
, AnyCPU
und DynamoSandbox
aus den Dropdown-Menüs aus, und klicken Sie dann auf Start
. Dadurch wird Dynamo erstellt, ein neuer Prozess (DynamoSandbox.exe) gestartet und der Visual Studio-Debugger an diesen angehängt.
Erstellen und starten Sie die Anwendung direkt über Visual Studio.
Legen Sie die Konfiguration auf
Debug
fest.Legen Sie die Plattform auf
Any CPU
fest.Legen Sie das Startprojekt auf
DynamoSandbox
fest.Klicken Sie auf
Start
, um den Debugging-Vorgang zu starten.
Alternativ können wir das Debugging auch für einen bereits ausgeführten Dynamo-Prozess durchführen, um ein Problem mit einem bestimmten geöffneten Diagramm oder Paket zu beheben. Zu diesem Zweck öffnen wir die Quelldateien des Projekts in Visual Studio und hängen sie mithilfe des Debug-Menüelements Attach to Process
an einen laufenden Dynamo-Prozess an.
Anhängen eines laufenden Prozesses an Visual Studio
Wählen Sie
Debug > Attach to Process...
aus.Wählen Sie
DynamoSandbox.exe
.Wählen Sie
Attach
aus.
In beiden Fällen hängen wir den Debugger an einen Prozess an, für den wir das Debugging ausführen möchten. Wir können vor oder nach dem Starten des Debuggers Haltepunkte im Code festlegen, die unmittelbar vor dem Ausführen dieser Codezeile eine Unterbrechung des Vorgangs bewirken. Wenn beim Debuggen eine nicht abgefangene Ausnahme ausgelöst wird, springt Visual Studio im Quellcode an die Stelle, an der diese aufgetreten ist. Dies ist eine effiziente Methode, um einfache Abstürze und nicht behandelte Ausnahmen zu finden und den Ausführungsablauf einer Anwendung zu verstehen.
Beim Debuggen von DynamoSandbox legen wir im Konstruktor des Blocks Color.ByARGB einen Haltepunkt fest, der bewirkt, dass der Dynamo-Prozess angehalten wird, wenn der Block instanziiert wird. Wenn dieser Block eine Ausnahme ausgelöst hat oder zu einem Absturz von Dynamo führte, können wir die einzelnen Zeilen im Konstruktor durchgehen, um zu ermitteln, wo das Problem aufgetreten ist.
Der Haltepunkt
Die Aufrufliste, die die derzeit ausgeführte Funktion und frühere Funktionsaufrufe anzeigt.
Im nächsten Abschnitt, Erstellen von DynamoRevit aus Quelldateien, wird ein spezifisches Debugging-Beispiel vorgestellt. Außerdem wird erläutert, wie Sie Haltepunkte festlegen, Code durchgehen und die Aufrufliste lesen.
Da die Dynamo-Quelldateien auf GitHub gehostet werden, lassen sich lokale Quelldateien am einfachsten auf dem aktuellen Stand halten, indem Sie Änderungen mithilfe von Git-Befehlen abrufen.
Legen Sie mithilfe der Befehlszeile das aktuelle Verzeichnis auf das Dynamo-Repository fest:
cd C:\Users\username\Documents\GitHub\Dynamo
Ersetzen Sie
"username"
durch Ihren Benutzernamen.
Verwenden Sie den folgenden Befehl, um die neuesten Änderungen abzurufen:
git pull origin master
Hier sehen wir, dass das lokale Repository mit Änderungen aus dem Remote-Repository aktualisiert wurde.
Zusätzlich zum Abrufen von Aktualisierungen gibt es vier weitere Git-Arbeitsabläufe, mit denen Sie sich vertraut machen sollten.
Fork: Spalten Sie das Dynamo-Repository auf, um eine vom Original separate Kopie zu erstellen. Hier vorgenommene Änderungen wirken sich nicht auf das ursprüngliche Repository aus. Aktualisierungen können mit Pull-Anforderungen abgerufen oder übermittelt werden. Fork ist kein Git-Befehl, sondern ein Arbeitsablauf, der von GitHub hinzugefügt wird. Das Fork-Pull-Anforderungsmodell ist einer der häufigsten Arbeitsabläufe für Online-Beiträge zu Open-Source-Projekten. Sie sollten sich näher damit beschäftigen, wenn Sie zu Dynamo beitragen möchten.
Verzweigung: Experimentieren Sie, oder arbeiten Sie an neuen Funktionen, unabhängig von den anderen Vorgängen in Verzweigungen. Dies erleichtert das Senden von Pull-Anforderungen.
Führen Sie häufig Commits aus, nachdem Sie einen Arbeitsschritt abgeschlossen haben bzw. nach Änderungen, die möglicherweise rückgängig gemacht werden sollen. Ein Commit zeichnet Änderungen im Repository auf und wird angezeigt, wenn eine Pull-Anforderung an das Dynamo-Haupt-Repository gestellt wird.
Erstellen Sie Pull-Anforderungen, wenn Änderungen bereit sind, offiziell im Dynamo-Haupt-Repository vorgeschlagen zu werden.
Das Dynamo-Team verfügt über spezielle Anweisungen zum Erstellen von Pull-Anforderungen. Weitere Informationen finden Sie im Abschnitt zu Pull-Anforderungen in dieser Dokumentation.
Eine Referenzliste der Git-Befehle finden Sie auf dieser Dokumentationsseite.