L'origine di Dynamo è ospitata su GitHub per consentire a chiunque di clonare e apportare contributi. In questo capitolo verrà illustrato come clonare il repository utilizzando git, compilare i file di origine con Visual Studio, eseguire una build locale e sottoporla a debug e infine effettuare eventuali nuove modifiche da GitHub.
GitHub è un servizio di hosting basato su git, un sistema di controllo delle versioni per tenere traccia delle modifiche e coordinare il lavoro tra le persone. git è uno strumento che possiamo sfruttare per scaricare i file di origine di Dynamo e mantenerli aggiornati con alcuni comandi. Utilizzando questo metodo si evita il lavoro superfluo e inevitabilmente complicato di dover scaricare e sostituire manualmente i file di origine ad ogni aggiornamento. Il sistema di controllo della versione di git consente di rilevare le differenze tra un repository di codici locale e remoto.
L'origine di Dynamo è ospitata nella pagina di DynamoDS su GitHub in questo repository: https://github.com/DynamoDS/Dynamo
I file di origine di Dynamo.
Clonare o scaricare l'intero repository.
Visualizza altri repository di DynamoDS.
File di origine di Dynamo.
File specifici di git.
Prima di poter clonare il repository, è necessario installare git. Seguire questa breve guida per la procedura di installazione e per impostare un nome utente e un indirizzo e-mail di GitHub. In questo esempio, si utilizzerà git nella riga di comando. Questa guida presuppone che si utilizzi Windows, ma è possibile utilizzare git anche su Mac o Linux per clonare i file di origine di Dynamo.
È necessario un URL dal quale clonare il repository di Dynamo. Questo è disponibile nel pulsante "Clone or download" nella pagina del repository. Copiare l'URL da incollare nella riga di comando.
Selezionare "Clone or download".
Copiare l'URL.
Con git installato, è possibile clonare il repository di Dynamo. Iniziare aprendo la riga di comando. Quindi, utilizzare il comando di cambio della directory cd per individuare la cartella in cui si desidera clonare i file di origine. In questo caso, è stata creata una cartella denominata Github in Documents.
cd C:\Users\username\Documents\GitHub
Sostituire "username" con il nome utente.
Nel passaggio successivo verrà eseguito un comando di git per clonare il repository di Dynamo nella posizione specificata. L'URL del comando si ottiene facendo clic sul pulsante "Clone or Download" su GitHub. Eseguire questo comando nel terminale di comando. Si noti che questa operazione consente di clonare il ramo principale del repository di Dynamo, che è il codice più aggiornato per Dynamo e che conterrà la versione più recente del codice di Dynamo. Questo ramo cambia ogni giorno.
git clone https://github.com/DynamoDS/Dynamo.git
Sappiamo che git funziona se l'operazione di clonazione è stata completata correttamente. In Esplora file, individuare la directory in cui è stata eseguita la clonazione per vedere i file di origine. La struttura della directory dovrebbe essere identica al ramo principale del repository di Dynamo su GitHub.
File di origine di Dynamo.
File di git
Con i file di origine ora clonati nel computer locale, è possibile creare un file eseguibile per Dynamo. A tale scopo, è necessario configurare l'IDE Visual Studio e verificare che siano installati .NET Framework e DirectX.
Scaricare e installare Microsoft Visual Studio Community 2015, un IDE (ambiente di sviluppo integrato) gratuito e completo ( potrebbero funzionare anche le versioni successive).
Scaricare e installare Microsoft .NET Framework 4.5 o versione successiva.
Installazione di Microsoft DirectX dal repository locale di Dynamo (Dynamo\tools\install\Extra\DirectX\DXSETUP.exe)
È possibile che .NET e DirectX siano già installati.
Al termine dell'installazione, è possibile avviare Visual Studio e aprire la soluzione Dynamo.All.sln situata in Dynamo\src.
Selezionare
File > Apri > Progetto/Soluzione.Individuare il repository di Dynamo e aprire la cartella
src.Selezionare il file della soluzione
Dynamo.All.sln.Selezionare
Apri.
Prima di poter creare la soluzione, è necessario specificare alcune impostazioni. È necessario innanzitutto creare una versione di debug di Dynamo in modo che Visual Studio possa raccogliere più informazioni durante il debug per facilitare lo sviluppo e si desidera dedicarsi a qualsiasi CPU.
Queste diventeranno cartelle all'interno della cartella
bin.
In questo esempio è stata scelta
Debugcome configurazione della soluzione.Impostare la piattaforma della soluzione su
Any CPU.
Con il progetto aperto, è possibile creare la soluzione. Questo processo creerà un file DynamoSandbox.exe che è possibile eseguire.
La compilazione del progetto ripristinerà le dipendenze NuGet.
Selezionare
Compilazione > Compila soluzione.Verificare che la build sia stata eseguita correttamente nella finestra Output. Il risultato dovrebbe essere simile a
==== Build: 69 succeeded, 0 failed, 0 up-to-date, 0 skipped ====.
Se Dynamo viene compilato correttamente, nel repository di Dynamo verrà creata una cartella bin con il file DynamoSandbox.exe. In questo caso, si sta eseguendo la compilazione con l'opzione Debug, in modo che il file eseguibile si trovi in bin\AnyCPU\Debug. L'esecuzione di questa operazione consente di aprire una build locale di Dynamo.
Il file eseguibile di DynamoSandbox appena creato. Eseguire questo file per avviare Dynamo.
Ora siamo quasi completamente pronti per iniziare lo sviluppo per Dynamo.
Per istruzioni sulla compilazione di Dynamo per altre piattaforme (ad esempio, Linux o OS X), visitare questa pagina Wiki.
Il debug è un processo di identificazione, isolamento e correzione di un bug o di un problema. Una volta che Dynamo è stato creato correttamente dall'origine, è possibile utilizzare diversi strumenti in Visual Studio per eseguire il debug di un'applicazione in esecuzione, ad esempio il modulo aggiuntivo DynamoRevit. È possibile analizzare il codice sorgente per individuare la causa di un problema o controllare il codice attualmente in esecuzione. Per una spiegazione più dettagliata su come eseguire il debug e spostarsi all'interno del codice in Visual Studio, consultare i documenti su Visual Studio.
Per l'applicazione Dynamo indipendente, DynamoSandbox, verranno descritte due opzioni per il debug:
Compilazione e avvio di Dynamo direttamente da Visual Studio
Associazione di Visual Studio ad un processo in esecuzione di Dynamo.
Se si avvia Dynamo da Visual Studio, viene ricreata la soluzione per ogni sessione di debug, se necessario, pertanto se si apportano modifiche all'origine, queste verranno incorporate durante il debug. Con la soluzione Dynamo.All.sln ancora aperta, selezionare Debug, AnyCPU e DynamoSandbox dai menu a discesa, quindi fare clic su Start. In questo modo verrà compilato Dynamo e verrà avviato un nuovo processo (DynamoSandbox.exe), al quale viene associato il debugger di Visual Studio.
Compilazione e avvio dell'applicazione direttamente da Visual Studio
Impostare la configurazione su
Debug.Impostare la piattaforma su
Any CPU.Impostare il progetto di avvio su
DynamoSandbox.Fare clic su
Startper avviare il processo di debug.
In alternativa, è possibile eseguire il debug di un processo di Dynamo che è già in esecuzione per risolvere un problema con un determinato pacchetto o grafico aperto. A questo scopo, si aprono i file di origine del progetto in Visual Studio e si associano ad un processo di Dynamo in esecuzione utilizzando la voce di menu di debug Attach to Process.
Associazione di un processo in esecuzione a Visual Studio
Selezionare
Debug > Connetti a processo.Scegliere
DynamoSandbox.exe.Selezionare
Connetti.
In entrambe le situazioni, il debugger viene associato ad un processo di cui si desidera eseguire il debug. È possibile impostare punti di interruzione nel codice prima o dopo l'avvio del debugger, in modo che il processo venga messo in pausa immediatamente prima di eseguire quella riga di codice. Se durante il debug viene generata un'eccezione non rilevata, Visual Studio passerà alla posizione in cui si è verificata nel codice sorgente. Si tratta di un metodo efficiente per individuare semplici arresti anomali, eccezioni non gestite e per comprendere il flusso di esecuzione di un'applicazione.
Durante il debug di DynamoSandbox, viene impostato un punto di interruzione nel costruttore del nodo Color.ByARGB che fa sì che il processo di Dynamo si metta in pausa quando viene creata l'istanza del nodo. Se questo nodo generava un'eccezione o causava l'arresto anomalo di Dynamo, si poteva eseguire ogni riga del costruttore per individuare il punto in cui si verificava il problema.
Il punto di interruzione
Lo stack di chiamate che mostra la funzione attualmente in esecuzione e le chiamate di funzioni precedenti.
Nella sezione successiva, Compilazione di DynamoRevit dall'origine, verrà illustrato un esempio specifico di debug e verrà descritto come impostare punti di interruzione, eseguire il codice una riga alla volta e leggere lo stack di chiamate.
Poiché l'origine di Dynamo è ospitata su GitHub, il modo più semplice per mantenere aggiornati i file di origine locali è quello di eseguire il pull delle modifiche utilizzando i comandi di git.
Utilizzando la riga di comando, impostare la directory corrente sul repository di Dynamo:
cd C:\Users\username\Documents\GitHub\Dynamo
Sostituire
"username"con il nome utente.
Utilizzare il seguente comando per eseguire il pull delle modifiche più recenti:
git pull origin master
Qui è possibile vedere che il repository locale è stato aggiornato con le modifiche da quello remoto.
Oltre al pull degli aggiornamenti, ci sono altri quattro workflow di git da conoscere.
Eseguire il fork del repository di Dynamo per creare una copia separata dall'originale. Eventuali modifiche apportate qui non influiranno sul repository originale e gli aggiornamenti possono essere recuperati da o inviati con richieste pull. Il fork non è un comando di git, ma è un workflow che GitHub aggiunge: fork, il modello della richiesta pull, è uno dei workflow più comuni per contribuire ai progetti open source in linea. Vale la pena di imparare se si vuole contribuire a Dynamo.
Ramo: si lavora a esperimenti o a nuove funzionalità isolate da altri lavori nei rami. In questo modo, è più semplice inviare richieste pull.
Eseguire spesso i commit dopo aver completato un'unità di lavoro e dopo una modifica che potrebbe essere utile annullare. Un commit registra le modifiche apportate al repository e sarà visibile quando si esegue una richiesta pull nel repository di Dynamo principale.
Creare richieste pull quando le modifiche sono pronte per essere ufficialmente proposte al repository di Dynamo principale.
Il team di Dynamo dispone di istruzioni specifiche per la creazione di richieste pull. Per informazioni più dettagliate sugli argomenti da trattare, fare riferimento alla sezione Richieste pull.
Vedere questa pagina della documentazione per un elenco di riferimento dei comandi di git.
I file di origine di DynamoRevit sono inoltre ospitati sulla pagina di DynamoDS su GitHub per consentire agli sviluppatori di apportare contributi e compilare versioni beta. La compilazione di DynamoRevit dall'origine segue generalmente lo stesso processo di Dynamo, ad eccezione di alcuni dettagli importanti:
DynamoRevit fa riferimento agli assiemi di Dynamo, quindi questi devono essere creati con i pacchetti NuGet corrispondenti. Ad esempio, DynamoRevit 2.x non verrà caricato in Dynamo 1.3.
DynamoRevit è specifico delle versioni di Revit, ad esempio: il ramo di DynamoRevit 2018 deve essere eseguita in Revit 2018.
Per questa guida utilizzeremo i seguenti elementi:
Revit 2023
La build più recente di DynamoRevit sul ramo Revit2023
La build più recente di Dynamo
Per garantire una corretta compilazione, verranno clonati e creati entrambi i repository di Dynamo e DynamoRevit da utilizzare in questa simulazione.
Nota La creazione manuale di Dynamo prima di DynamoRevit è necessaria solo se si sta creando Dynamo 1.x e DynamoRevit 1.x. Le versioni più recenti del repository di DynamoRevit si basano su Gestione pacchetti NuGet per le dipendenze di Dynamo necessarie per la creazione. Sebbene una build di DynamoRevit 2.x non richieda il pull manuale di Dynamo, sarà comunque necessario disporre dei file dlls di Core in un altro punto per eseguire effettivamente DynamoRevitaddin, pertanto vale la pena di eseguire il pull e la compilazione di Dynamo comunque. Per ulteriori informazioni, vedere Compilazione del repository utilizzando Visual Studio.
Il codice per il progetto di DynamoRevit si trova in un repository su GitHub separato dal codice sorgente di Dynamo principale. Questo repository contiene i file di origine per i nodi specifici di Revit e il modulo aggiuntivo di Revit che carica Dynamo. Le build di DynamoRevit per versioni diverse di Revit (ad esempio, 2016, 2017 o 2018) sono organizzate come rami nel repository.
L'origine di DynamoRevit è ospitata qui: https://github.com/DynamoDS/DynamoRevit.
Clonare o scaricare il repository.
I rami di DynamoRevit fanno riferimento alle versioni di Revit.
In un processo simile al pull del repository di Dynamo, utilizzeremo il comando clone di git per clonare DynamoRevit e specificare il ramo che corrisponde alla nostra versione di Revit. Per iniziare, apriremo un'interfaccia della riga di comando e imposteremo la directory corrente sul percorso in cui desideriamo clonare i file.
cd C:\Users\username\Documents\GitHub modifica la directory corrente.
Sostituire
usernamecon il nome utente.
Ora possiamo clonare il repository in questa directory. Sebbene sia necessario specificare un ramo del repository, possiamo passare a questo ramo dopo la clonazione.
git clone https://github.com/DynamoDS/DynamoRevit.git clona il repository da un URL remoto e, per default, passa al ramo principale.
Una volta terminata la clonazione del repository, cambiare la directory corrente con la cartella del repository e passare al ramo corrispondente alla versione di Revit installata. In questo esempio, utilizziamo Revit RC2.13.1_Revit2023. Tutti i rami remoti possono essere visualizzati nella pagina su GitHub nel menu a discesa Branch.
cd C:\Users\username\Documents\GitHub\DynamoRevit modifica la directory in DynamoRevit.
git checkout RC2.13.1_Revit2023 imposta il ramo corrente su RC2.13.1_Revit2023.
git branch verifica in quale ramo siamo e mostra gli altri che esistono localmente.
Il ramo con un asterisco è quello attualmente estratto. Il ramo
Revit2018è visibile perché lo abbiamo estratto in precedenza, pertanto esiste localmente.
È importante scegliere il ramo corretto del repository per assicurarsi che, quando il progetto viene compilato in Visual Studio, faccia riferimento agli assiemi nella versione corretta della directory di installazione di Revit, in particolare RevitAPI.dll e RevitAPIUI.dll.
Prima di compilare il repository, è necessario ripristinare i pacchetti NuGet con il file restorepackages.bat situato nella cartella src. Questo file .bat utilizza Gestione pacchetti NuGet per eseguire il pull dei file binari creati di Dynamo Core, di cui DynamoRevit ha bisogno. Si potrebbe anche scegliere di compilarli manualmente, ma solo se si stanno apportando modifiche a DynamoRevit e non a Dynamo Core. In questo modo, è possibile iniziare a lavorare più velocemente. Assicurarsi di eseguire il file come amministratore.
Fare clic con il pulsante destro del mouse su
restorepackages.bate selezionareRun as administrator.
Se i pacchetti vengono ripristinati correttamente, una cartella packages verrà aggiunta alla cartella src con i pacchetti NuGet della versione beta più recenti.
I pacchetti NuGet di Dynamo della versione beta più recenti
Una volta ripristinati i pacchetti, aprire il file della soluzione di Visual Studio DynamoRevit.All.sln in src e creare la soluzione. Inizialmente la build potrebbe avere problemi a trovare AssemblySharedInfo.cs. In questo caso, la riesecuzione della build risolverà il problema.
Selezionare
Build > Build Solution.Verificare che la build sia stata eseguita correttamente nella finestra Output. Dovrebbe essere visualizzato il messaggio
===== Build: 13 succeeded, 0 failed, 0 up-to-date, 0 skipped =====.
Per riconoscere DynamoRevit, in Revit è richiesto un file .addin, che il programma di installazione creerà automaticamente. Nello sviluppo è necessario creare manualmente un file .addin che punti alla build di DynamoRevit che si desidera, in particolare l'assieme DynamoRevitDS.dll. Dobbiamo inoltre puntare DynamoRevit ad una build di Dynamo.
Creare un file Dynamo.addin nella cartella Addins di Revit che si trova in C:\ProgramData\Autodesk\Revit\Addins\2023. Abbiamo già installato una versione di DynamoRevit, quindi modificheremo il file esistente in modo che punti alla nuova build.
Specificare il percorso del file DynamoRevitDS.dll all'interno di <Assembly>...</Assembly>.
In alternativa, possiamo fare in modo che il modulo aggiuntivo carichi il selettore di versione anziché un assieme specifico.
Impostare il percorso del file <Assembly>...</Assembly> su DynamoRevitVersionSelector.dll.
<FullClassName>...</FullClassName> specifica la classe di cui creare un'istanza dall'assieme a cui abbiamo puntato con il percorso dell'elemento assieme indicato sopra. Questa classe sarà il punto di ingresso per il modulo aggiuntivo.
Inoltre, dobbiamo rimuovere la cartella di Dynamo esistente fornita con Revit. A tale scopo, accedere a C:\\Program Files\Autodesk\Revit 2023\AddIns e rimuovere le due cartelle che contengono Dynamo - DynamoForRevit e DynamoPlayerForRevit. È possibile eliminarle o eseguirne il backup in una cartella separata se è necessario recuperare la cartella di Dynamo for Revit originale.
Il secondo passaggio consiste nell'aggiungere un percorso di file per gli assiemi di Dynamo Core al file Dynamo.config nella cartella bin di DynamoRevit. DynamoRevit li carica quando il modulo aggiuntivo viene aperto in Revit. Questo file .config consente di puntare il modulo aggiuntivo DynamoRevit a versioni diverse di Dynamo Core per lo sviluppo e la verifica delle modifiche sia in Dynamo Core che in DynamoRevit.
Il codice dovrebbe avere un aspetto simile al seguente:
Aggiungere il percorso della directory della cartella bin a <add key/>.
Abbiamo clonato e creato Dynamo subito prima di questa simulazione per garantire che funzioni correttamente con DynamoRevit. Il percorso della directory punta a questa build.
Ora, quando si apre Revit, dovrebbe essere presente un modulo aggiuntivo Dynamo nella scheda Gestisci.
Selezionare
Manage.Fare clic sull'icona del modulo aggiuntivo Dynamo.
Un'istanza di DynamoRevit.
Se viene visualizzata una finestra di dialogo di errore che mostra gli assiemi mancanti, è probabile che si sia verificata una mancata corrispondenza tra le versioni di Dynamo Core create e quelle caricate in fase di esecuzione. Ad esempio, DynamoRevit con i pacchetti beta più recenti 2.0 di Dynamo Core non funzionerà se si tenta di avviarlo utilizzando i file .dll di Dynamo 1.3. Assicurarsi che entrambe i repository siano della stessa versione e che DynamoRevit stia eseguendo il pull di una versione corrispondente delle dipendenze NuGet. Questi sono definiti nel file package.json del repository di DynamoRevit.
Nella sezione precedente, Compilazione di Dynamo dall'origine, abbiamo introdotto brevemente il debug in Visual Studio e come associare Visual Studio ad un processo. Utilizzando un'eccezione nel nodo Wall.ByCurveAndHeight come esempio, verrà illustrato come eseguire l'associazione ad un processo, impostare i punti di interruzione, eseguire il codice una riga alla volta e utilizzare lo stack di chiamate per determinare l'origine dell'eccezione. Questi strumenti di debug si applicano in genere ai workflow di sviluppo di file .net e sono utili per l'esplorazione al di fuori di questa guida.
L'associazione ad un processo collega un'applicazione in esecuzione a Visual Studio per il debug. Se si desidera eseguire il debug di un funzionamento che si verifica in una build di DynamoRevit, è possibile aprire i file di origine di DynamoRevit in Visual Studio e associare il processo Revit.exe, che è il processo principale del modulo aggiuntivo DynamoRevit. Visual Studio utilizza un file di simboli (.pbd) per stabilire la connessione tra gli assiemi in esecuzione in DynamoRevit e il codice sorgente.
I punti di interruzione stabiliscono le righe del codice sorgente in cui l'applicazione verrà messa in pausa prima dell'esecuzione. Se un nodo causa l'arresto anomalo di DynamoRevit o restituisce un risultato imprevisto, è possibile aggiungere un punto di interruzione all'origine del nodo per mettere in pausa il processo, eseguire l'istruzione nel codice ed esaminare i valori attivi delle variabili fino a quando non viene individuata la causa del problema.
L'esecuzione del codice una riga alla volta consente di spostarsi nel codice sorgente riga per riga. È possibile eseguire le funzioni una alla volta, eseguire l'istruzione in una chiamata di funzione o uscire dalla funzione attualmente in esecuzione.
Lo stack di chiamate mostra la funzione che un processo è attualmente in esecuzione rispetto alle chiamate di funzione precedenti che hanno richiamato questa chiamata di funzione. Per visualizzare questa finestra, in Visual Studio è disponibile la finestra Call Stack. Ad esempio, se si raggiunge un'eccezione al di fuori del codice sorgente, è possibile visualizzare il percorso del codice chiamante nello stack di chiamate.
2,000 Things You Should Know About C# presenta una spiegazione più approfondita degli stack di chiamate.
Il nodo Wall.ByCurveAndHeight genera un'eccezione quando viene fornito il valore PolyCurve come input curve con il messaggio: To BSPlineCurve Not Implemented. Con il debug si può capire perché esattamente il nodo non accetta questo tipo di geometria come input per il parametro curve. In questo esempio, si presuppone che DynamoRevit sia stato creato correttamente e possa essere eseguito come modulo aggiuntivo per Revit.
Il nodo Wall.ByCurveAndHeight che genera un'eccezione
Iniziare aprendo il file della soluzione DynamoRevit.All.sln, avviare Revit e avviare il modulo aggiuntivo DynamoRevit. Quindi, associare Visual Studio al processo di Revit con la finestra Attach to Process.
È necessario che Revit e DynamoRevit siano in esecuzione per essere mostrati come processo disponibile
Aprire la finestra
Attach to ProcessselezionandoDebug > Attach to Process....Impostare
TransportsuDefault.Selezionare
Revit.exe.Selezionare
Attach.
Con Visual Studio associato a Revit, aprire il codice sorgente Wall.ByCurveAndHeight in Wall.cs. È possibile trovare questa opzione in Solution Explorer in Libraries > RevitNodes > Elements nell'area Public static constructors del file. Impostare un punto di interruzione nel costruttore del tipo di muro in modo, che quando il nodo viene eseguito in Dynamo, il processo si interrompa e si possa eseguire ogni singola riga di codice. In genere, i costruttori di tipo zero-touch di Dynamo iniziano con By<parameters>.
Il file di classe con il costruttore per Wall.ByCurveAndHeight
Impostare un punto di interruzione facendo clic a sinistra del numero di riga o facendo clic con il pulsante destro del mouse sulla riga di codice e selezionare
Breakpoint > Insert Breakpoint.
Con il punto di interruzione impostato, è necessario eseguire il processo attraverso la funzione Wall.ByCurveAndHeight. La funzione può essere eseguita nuovamente in Dynamo riconnettendo un filo ad una delle relative porte, il che forzerà la riesecuzione del nodo. Il punto di interruzione verrà rilevato in Visual Studio.
L'icona del punto di interruzione cambia quando viene rilevato
La finestra Call Stack che mostra il metodo successivo
Ora eseguire ogni riga del costruttore fino a quando non viene rilevata l'eccezione. Il codice evidenziato in giallo è l'istruzione successiva da eseguire.
Gli strumenti di debug per la navigazione nel codice
Premere
Step Overper eseguire il codice evidenziato, quindi sospendere l'esecuzione dopo la restituzione della funzione.L'istruzione successiva da eseguire è indicata dall'evidenziazione gialla e dalla freccia.
Se si continua a eseguire la funzione, si rileverà l'eccezione visualizzata nella finestra di DynamoRevit. Osservando la finestra Call Stack, si può vedere che l'eccezione è stata originariamente generata da un metodo denominato Autodesk.Revit.CurveAPIUtils.CreateNurbsCurve. Fortunatamente in questo caso l'eccezione è stata risolta e Dynamo non si è arrestato in modo anomalo. Il processo di debug ha fornito il contesto per il problema, portandoci a un altro metodo nel codice sorgente.
Poiché non si tratta di una libreria open source, non si possono apportare modifiche. Ora che si hanno ulteriori informazioni, è possibile segnalare il problema con maggiore contesto, presentando un problema su GitHub o si potrebbe proporre una soluzione per questo problema eseguendo una richiesta pull.
Quando si rileva l'istruzione che causa l'eccezione in
Walls.cs, il processo di debug ci avvicina il più possibile alla causa del problema nel codice utente all'interno diProtoToRevitCurve.cs.L'istruzione che causa l'eccezione in
ProtoToRevitCurve.csNella finestra Call Stack, è possibile vedere che l'eccezione proviene da codice non utente.
Una finestra a comparsa che fornisce informazioni sull'eccezione
Questo processo può essere applicato a qualsiasi file di origine utilizzato. Se si sta sviluppando una libreria di nodi zero-touch per Dynamo Studio, è possibile aprire l'origine della libreria e associare un processo di Dynamo per eseguire il debug della libreria dei nodi. Anche se tutto funziona perfettamente, il debug è un ottimo modo per esplorare il codice e scoprire come funziona.
Questo processo è quasi identico al pull delle modifiche per Dynamo, tranne per il fatto che è necessario verificare di trovarsi nel ramo corretto. Utilizzare il comando git branch nel repository di DynamoRevit per vedere quali rami sono disponibili localmente e quali sono attualmente estratti.
cd C:\Users\username\Documents\GitHub\DynamoRevit imposta la directory corrente sul repository di DynamoRevit.
git branch verifica che ci troviamo nel ramo corretto, RC2.13.1_Revit2023.
git pull origin RC2.13.1_Revit2023 esegue il pull delle modifiche dal ramo RC2.13.1_Revit2023 di origine remota.
L'origine punta semplicemente all'URL originale clonato.
Si desidera essere consapevoli del ramo in cui ci si trova attualmente e di quello da cui ci sta eseguendo il pull per evitare, ad esempio, di effettuare il pull delle modifiche da
RC2.13.1_Revit2023aRevit2018.
Come indicato in Creazione di Dynamo dall'origine, quando si è pronti per inviare una modifica al repository di DynamoRevit, è possibile creare una richiesta pull seguendo le linee guida del team di Dynamo riportate nella sezione Richieste pull.
