Dynamo
Primer for v2.0
Italiano
Italiano
  • Informazioni
  • Introduzione
    • Che cos'è Dynamo e come funziona?
    • Guida introduttiva, comunità e piattaforma di Dynamo
  • Installazione per Dynamo
  • Interfaccia utente
    • Area di lavoro
    • Libreria
  • Nodi e fili
  • Nodi e concetti essenziali
    • Indice dei nodi
    • Geometria per la progettazione computazionale
      • Panoramica sulla geometria
      • Vettore, piano e sistema di coordinate
      • Punti
      • Curve
      • Superfici
      • Solidi
      • Mesh
    • Elementi di base dei programmi
      • Dati
      • Matematica
      • Logica
      • Stringhe
      • Colore
    • Progettazione con elenchi
      • Che cos'è un elenco?
      • Utilizzo di elenchi
      • Elenchi di elenchi
      • Elenchi n-dimensionali
    • Dizionari in Dynamo
      • Che cos'è un dizionario?
      • Nodi Dictionary
      • Dizionari nei blocchi di codice
      • Casi di utilizzo di Revit
  • Pacchetti e nodi personalizzati
    • Nodi personalizzati
      • Introduzione ai nodi personalizzati
      • Creazione di un nodo personalizzato
      • Pubblicazione nella libreria
    • Pacchetti
      • Introduzione ai pacchetti
      • Case study di un pacchetto - Mesh Toolkit
      • Sviluppo di un pacchetto
      • Pubblicazione di un pacchetto
      • Importazione zero-touch
  • Dynamo per Revit
    • Correlazione con Revit
    • Selezione
    • Modifica
    • Creazione
    • Personalizzazione
    • Documentazione
  • Dynamo for Civil 3D
    • Connessione a Civil 3D
    • Per iniziare
    • Libreria di nodi
    • Esempi di workflow
      • Strade
        • Posizionamento di lampioni
      • Gestione catastale
        • Posizionamento dei servizi
      • Impianti di pubblica utilità
        • Ridenominazione di strutture
      • Ferrovia
        • Sagoma dello spazio libero
      • Rilievi
        • Gestione di gruppi di punti
    • Argomenti avanzati
      • Unione di oggetti
      • Python e Civil 3D
    • Lettore Dynamo
    • Pacchetti utili
    • Risorse
  • Codifica in Dynamo
    • Blocchi di codice e DesignScript
      • Cos'è un blocco di codice?
      • Sintassi di DesignScript
      • Sintassi abbreviata
      • Funzioni
    • Geometria con DesignScript
      • Nozioni di base della geometria DesignScript
      • Primitive geometriche
      • Matematica vettoriale
      • Curve: punti interpolati e di controllo
      • Traslazione, rotazione e altre trasformazioni
      • Superfici: punti interpolati e di controllo, loft, rivoluzione
      • Parametrizzazione geometrica
      • Intersezione e taglio
      • Operazioni booleane geometriche
      • Generatori di punti di Python
    • Python
      • Nodi Python
      • Python e Revit
      • Impostazione del modello di Python personalizzato
    • Modifiche al linguaggio
  • Procedure ottimali
    • Strategie sui grafici
    • Strategie di scripting
    • Riferimento per lo scripting
    • Gestione del programma
    • Utilizzo efficiente di set di dati di grandi dimensioni in Dynamo
  • Esempi di workflow
    • Introduzione ai workflow
      • Vaso parametrico
      • Punti attrattore
    • Indice concettuale
  • Guida introduttiva per sviluppatori
    • Compilazione di Dynamo dalla sorgente
      • Compilazione di DynamoRevit dalla sorgente
      • Gestione e aggiornamento delle dipendenze in Dynamo
    • Sviluppo per Dynamo
      • Per iniziare
      • Case study zero-touch - Nodo griglia
      • Esecuzione di script Python in nodi zero-touch (C#)
      • Ulteriori informazioni sul concetto di zero-touch
      • Personalizzazione avanzata dei nodi di Dynamo
      • Utilizzo di tipi COM (interoperabilità) nei pacchetti di Dynamo
      • Case study NodeModel - Interfaccia utente personalizzata
      • Aggiornamento di pacchetti e librerie di Dynamo per Dynamo 2.x
      • Aggiornamento di pacchetti e librerie di Dynamo per Dynamo 3.x
      • Estensioni
      • Definizione dell'organizzazione di pacchetti personalizzati (Dynamo 2.0 e versioni successive)
      • Interfaccia della riga di comando di Dynamo
      • Integrazione per Dynamo
      • Sviluppo per Dynamo for Revit
      • Pubblicazione di un pacchetto
      • Creazione di un pacchetto da Visual Studio
      • Estensioni come pacchetti
    • Richieste pull
    • Aspettative di test
    • Esempi
  • Appendice
    • Domande frequenti
    • Programmazione visiva e Dynamo
    • Risorse
    • Note di rilascio
    • Pacchetti utili
    • File di esempio
    • Mappa di integrazione host
    • Download del file PDF
    • Tasti di scelta rapida di Dynamo
Powered by GitBook
On this page
Edit on GitHub
Export as PDF
  1. Guida introduttiva per sviluppatori
  2. Sviluppo per Dynamo

Creazione di un pacchetto da Visual Studio

PreviousPubblicazione di un pacchettoNextEstensioni come pacchetti

Last updated 1 month ago

Se si stanno sviluppando assiemi da pubblicare come pacchetto per Dynamo, il progetto può essere configurato per raggruppare tutti i componenti di progetto necessari e inserirli in una struttura di directory compatibile con il pacchetto. Ciò consentirà di testare rapidamente il progetto come pacchetto e di simulare l'esperienza dell'utente.

Come creare direttamente un pacchetto nella cartella corrispondente

In Visual Studio sono disponibili due metodi per la creazione di un pacchetto:

  • Aggiungere eventi post-compilazione tramite la finestra di dialogo Project Settings che utilizzano script xcopy o Python per copiare i file necessari

  • Utilizzare la destinazione della build "AfterBuild" nel file .csproj per creare le operazioni di copia di file e directory.

"AfterBuild" è il metodo preferito per questi tipi di operazioni (e quello descritto in questo manuale), poiché non si basa sulla copia di file che potrebbe non essere disponibile nel computer di compilazione.

Copia di file di pacchetto con il metodo AfterBuild

Impostare la struttura delle directory nel repository in modo che i file di origine siano separati dai file di pacchetto. Utilizzando il case study CustomNodeModel, posizionare il progetto di Visual Studio e tutti i file associati in una nuova cartella src. Verranno memorizzati tutti i pacchetti generati dal progetto in questa cartella. La struttura delle cartelle dovrebbe ora essere simile alla seguente:

CustomNodeModel
> src
  > CustomNodeModel
  > CustomNodeModelFunction
  > packages
  > CustomNodeModel.sln
  1. Spostare i file di progetto nella nuova cartella src

  <Target Name="AfterBuild">
    <ItemGroup>
      <Dlls Include="$(OutDir)*.dll" />
      <Pdbs Include="$(OutDir)*.pdb" />
      <Xmls Include="$(OutDir)*.xml" />
      <Configs Include="$(OutDir)*.config" />
    </ItemGroup>
    <Copy SourceFiles="@(Dlls)" DestinationFolder="$(SolutionDir)..\packages\CustomNodeModel\bin\" />
    <Copy SourceFiles="@(Pdbs)" DestinationFolder="$(SolutionDir)..\packages\CustomNodeModel\bin\" />
    <Copy SourceFiles="@(Xmls)" DestinationFolder="$(SolutionDir)..\packages\CustomNodeModel\bin\" />
    <Copy SourceFiles="@(Configs)" DestinationFolder="$(SolutionDir)..\packages\CustomNodeModel\bin\" />
    <MakeDir Directories="$(SolutionDir)..\packages\CustomNodeModel\dyf" />
    <MakeDir Directories="$(SolutionDir)..\packages\CustomNodeModel\extra" />
  </Target>

Sarà necessario verificare che la destinazione sia stata aggiunta al file CustomNodeModel.csproj (non ad un altro file di progetto) e che per il progetto non siano state definite impostazioni post-compilazione esistenti.

  1. Posizionare la destinazione AfterBuild prima del tag </Project> finale.

Nella sezione <ItemGroup>, vengono definite diverse variabili per rappresentare tipi di file specifici. Ad esempio, la variabile Dll rappresenta tutti i file nella directory di output con estensione .dll.

<ItemGroup>
  <Dlls Include="$(OutDir)*.dll" />
</ItemGroup>

L'operazione Copy consiste nel copiare tutti i file .dll in una directory, in particolare nella cartella del pacchetto in cui si sta eseguendo la compilazione.

<Copy SourceFiles="@(Dlls)" DestinationFolder="$(SolutionDir)..\packages\CustomNodeModel\bin\" />

I pacchetti di Dynamo in genere dispongono di una cartella dyf e extra per i nodi personalizzati di Dynamo e altri componenti di progetto, ad esempio le immagini. Per creare queste cartelle, è necessario utilizzare un'attività MakeDir. Questa operazione creerà una cartella se non esiste. È possibile aggiungere i file manualmente a questa cartella.

<MakeDir Directories="$(SolutionDir)..\packages\CustomNodeModel\extra" />

Se si crea il progetto, la cartella di progetto dovrebbe ora avere una cartella packages accanto alla cartella src creata in precedenza. All'interno della directory packages è presente una cartella contenente tutti gli elementi necessari per il pacchetto. È inoltre necessario copiare il file pkg.json nella cartella del pacchetto in modo che Dynamo sappia di caricare il pacchetto.

  1. La nuova cartella del pacchetto creata dalla destinazione AfterBuild

  2. La cartella src esistente con il progetto

  3. Le cartelle dyf e extra create dalla destinazione AfterBuild

  4. Copiare manualmente il file pkg.json.

Ora è possibile pubblicare il pacchetto utilizzando il gestore di pacchetti di Dynamo o copiarlo direttamente nella directory del pacchetto di Dynamo: <user>\AppData\Roaming\Dynamo\1.3\packages.

Ora che i file di origine si trovano in una cartella separata, aggiungere una destinazione AfterBuild al file CustomNodeModel.csproj in Visual Studio. In questo modo, i file necessari dovrebbero essere copiati in una nuova cartella del pacchetto. Aprire il file CustomNodeModel.csproj in un editor di testo (è stato utilizzato ) e posizionare la destinazione della build prima del tag </Project> di chiusura. Questa destinazione AfterBuild copierà tutti i file .dll, .pbd, .xml e .config in una nuova cartella bin e creerà una cartella dyf e cartelle extra.

Atom
Spostamento dei file di progetto
Posizionamento della destinazione AfterBuild
Copia di file