Generate code from UML class diagrams

 

Per la documentazione più recente di Visual Studio 2017 RC, vedere Documentazione di Visual Studio 2017 RC.

Per generare codice Visual C# .NET da diagrammi classi UML in Visual Studio, usare il Genera codice comando. Per impostazione predefinita, il comando genera un tipo C# per ogni tipo UML selezionato. Tale comportamento può essere modificato o esteso modificando o copiando i modelli di testo che generano il codice. È possibile specificare un comportamento differente per i tipi contenuti nei vari pacchetti del modello.

Il comando Genera codice è particolarmente indicato per la generazione di codice in base alla selezione degli elementi da parte dell'utente e per la generazione di un file per ogni classe o altro elemento UML. Ad esempio, nella schermata seguente sono illustrati due file C# generati da due classi UML.

In alternativa, se si desidera generare codice nel quale i file generati non dispongono di una relazione 1:1 con gli elementi UML, è possibile scrivere modelli di testo che vengano richiamati con il comando Trasforma tutti i modelli. Per altre informazioni sul metodo Generate files from a UML model.

Diagramma di classi UML e file di classe C# generati

Per altre informazioni sui diagrammi classi UML in Visual Studio, vedere gli argomenti seguenti:

Per informazioni sulle versioni di Visual Studio che supportano i diagrammi classi UML, vedere Supporto della versione per gli strumenti di architettura e modellazione.

Nella procedura seguente viene descritto il comportamento predefinito del comando Genera codice:

Per generare un file separato per ogni elemento

  1. Creare un modello UML contenente classi. È possibile applicare stereotipi agli elementi del modello.

    Per altre informazioni, vedere Trasformazioni della generazione di codice predefinita.

  2. In un diagramma classi o in Esplora modelli UML, selezionare gli elementi dai quali si desidera generare il codice. È possibile effettuare una delle seguenti selezioni:

    • Un set specifico di elementi.

    • Un pacchetto o il modello, dal cui contenuto generare il codice.

    • Il diagramma, per selezionarne tutti gli elementi.

  3. Aprire il menu di scelta rapida per un elemento selezionato, quindi scegliere Genera codice.

    Al primo utilizzo del comando Genera codice in un particolare modello, viene visualizzata una finestra di dialogo che consente di modificare i parametri di generazione del codice del modello.

    Scegliere OK a meno che non si ritenga di dover modificare questi parametri.

    Per tornare alla finestra di dialogo in un secondo momento, aprire Esplora modelli UML. Aprire il menu di scelta rapida del progetto di modellazione e quindi scegliere Configura generazione codice. Per altre informazioni, vedere Personalizzazione del comando Genera codice.

Vengono generati i file contenenti il codice C#. Nel caso predefinito, viene generato per ogni tipo un file in un progetto Libreria di classi C#. È tuttavia possibile personalizzare tale comportamento. Per altre informazioni, vedere Personalizzazione del comando Genera codice.

Al modello vengono applicati alcuni test di convalida per verificare che possa essere convertito in C#. Se i test hanno esito negativo, viene visualizzato un messaggio di errore e la generazione di codice non viene eseguita. Se si è creato un comando di menu di convalida, il codice non viene generato per gli elementi per i quali il comando di convalida ha esito negativo. Per altre informazioni, vedere Definire vincoli di convalida per i modelli UML.

In questa sezione vengono riepilogati i risultati prodotti dal comando Genera codice quando questo non è stato personalizzato. Per altre informazioni, vedere Personalizzazione del comando Genera codice.

  • Per ogni tipo selezionato nel modello UML viene generato un tipo C#. Ogni tipo viene inserito in un file di codice separato nella cartella GeneratedCode.

  • Se il tipo UML è contenuto in un pacchetto, il tipo C# generato viene inserito in uno spazio dei nomi e il file viene generato in una cartella con lo stesso nome dello spazio dei nomi.

  • Per ogni elemento Attribute di una classe UML viene generata una proprietà C#.

  • Per ogni elemento Operation di un tipo UML viene generato un metodo C#.

  • Per ogni associazione navigabile cui partecipa la classe viene generato un campo C#.

Aggiungendo uno stereotipo a ogni tipo UML, è possibile controllare più proprietà del tipo C# generato.

Per creare il tipo C#Creare il tipo UMLApplicare lo stereotipo
ClasseClasse<none> oppure

Classe C#
InterfacciaInterfaccia<none> oppure

Interfaccia C#
EnumerazioneEnumerazione<none> oppure

C# enum
DelegatoClasseDelegato C#
StructClasseC# struct

Per impostare uno stereotipo su un tipo o su un altro elemento

  1. Aprire il menu di scelta rapida per l'elemento in un diagramma oppure in Esplora modelli UML, quindi scegliere Proprietà.

  2. Nella finestra Proprietà fare clic sulla freccia a discesa per la proprietà Stereotipi e selezionare la casella di controllo relativa allo stereotipo da applicare.

    System_CAPS_ICON_tip.jpg Suggerimento

    Se gli stereotipi C# non sono visualizzati, abilitare il profilo C# per il modello o per un pacchetto contenente gli elementi del modello desiderati. Selezionare il pacchetto o la radice del modello in Esplora modelli UML. Nella finestra Proprietà scegliere Profilo e abilitare il profilo C#.

  3. Espandere la proprietà Stereotypes per visualizzare le proprietà aggiuntive che è possibile impostare.

Le proprietà Description di tipi, attributi, operazioni e associazioni sono scritte in commenti <summary> all'interno del codice generato. Gli elementi di commento collegati ai tipi sono scritti in commenti <remarks>.

Il codice generato varia in base alle proprietà di ciascun tipo, attributo o operazione. Ad esempio, se si imposta la proprietà Is Abstract di una classe su true, nella classe generata verrà visualizzata la parola chiave abstract. Se si imposta la proprietà Multiplicity di un attributo su 0..*, la proprietà generata disporrà di un tipo IEnumerable<>.

Inoltre, ogni stereotipo fornisce varie proprietà aggiuntive che è possibile impostare. Questi valori vengono convertiti nelle parole chiave appropriate nel codice C#. Ad esempio, se si imposta la proprietà Is Static su una classe, la classe C# sarà static.

Per impostare queste proprietà aggiuntive, selezionare la classe o un altro elemento nel diagramma. Nella finestra Proprietà espandere Stereotypes, quindi espandere lo stereotipo C#, ad esempio Classe C#. Per le classi, tali proprietà aggiuntive includono:

  • CLR Attributes

  • Is Partial

  • Is Static

  • Is Unsafe

  • Package Visibility

Ogni attributo e operazione dispone di proprietà di stereotipo che è possibile impostare. Se per un nuovo attributo non sono visualizzate le relative proprietà, eseguire Genera codice.

Il comando Genera codice comporta la trasformazione degli elementi del modello mediante un set di modelli di testo. Per altre informazioni sui modelli di testo, vedere Code Generation and T4 Text Templates.

I modelli vengono specificati in un set di binding a modello di testo. Un binding a modello di testo specifica il modello da applicare, la destinazione dell'output che verrà generato e gli altri parametri del comando Genera codice.

Alla prima esecuzione per un particolare modello, il comando Genera codice collega un set predefinito di binding a modello alla radice del modello. Questi binding si applicano a tutti gli elementi del modello.

Tuttavia, è possibile eseguire l'override e aggiungere, a questi binding predefiniti, binding personalizzati a pacchetti, classi o altri elementi. Un binding si applica a tutti gli elementi contenuti nell'elemento a cui è collegata. Ad esempio, se si desidera che tutti i tipi contenuti in un particolare pacchetto vengano trasformati in base a un differente set di modelli o che vengano estratti in una diversa cartella, è possibile collegare i binding a modello al pacchetto.

Per controllare i template binding a modello collegati a un elemento del modello, fare clic sul pulsante con i puntini di sospensione [...] nella proprietà Associazioni modelli di testo nella finestra Proprietà.

Il comando Genera codice applica i modelli a ciascun elemento del modello selezionato. Per ogni elemento, il set di modelli applicato è il set combinato dei modelli associati ai relativi contenitori, fino alla radice del modello inclusa.

Se due binding a modello in questo set hanno lo stesso nome, il binding nel contenitore più piccolo esegue l'override del binding nel contenitore più grande. Ad esempio, la radice del modello contiene un binding denominato Class Template. Per assicurarsi che il modello personalizzato venga applicato al contenuto di un particolare pacchetto, definire il binding a modello personalizzato denominato Class Template.

È possibile applicare più modelli a un elemento del modello, nonché generare più file da ciascun elemento del modello.

System_CAPS_ICON_note.jpg Nota

I binding collegati alla radice del modello fungono da binding predefiniti per tutti gli elementi del modello. Per visualizzare questi binding predefiniti, aprire Esplora modelli UML. Aprire il menu di scelta rapida del progetto di modellazione, quindi scegliere Configura generazione codice. In alternativa è possibile selezionare la radice del modello in Esplora modelli UML. Nella finestra Proprietà fare clic su […] nella proprietà Associazioni modelli di testo. I binding non verranno visualizzati finché non si sia usato il comando Genera codice almeno una volta. Non è possibile collegare binding a modello a un diagramma.

Per collegare binding a modello di testo a un pacchetto o a un altro elemento del modello

  1. In Esplora modelli UML aprire il menu di scelta rapida per un elemento del modello, quindi scegliere Proprietà. In genere, i binding a modello di testo vengono collegati a un pacchetto o alla radice del modello.

  2. Nella finestra Proprietà fare clic sul pulsante con i puntini di sospensione ([…]) nella proprietà Associazioni modelli di testo.

    Verrà visualizzata la finestra di dialogo Associazioni modelli di testo.

  3. Scegliere Aggiungi per creare un nuovo binding a un modello di testo.

    -oppure-

    Scegliere un binding esistente per modificarla.

    Ogni binding a modello definisce la modalità di applicazione di un modello specificato all'elemento del modello selezionato e agli altri elementi in questo contenuti.

  4. Nella finestra di dialogo, impostare le proprietà del binding a modello di testo.

    ProprietàDescrizione
    NomeNome per il binding. Per eseguire l'override di un binding ereditato da un pacchetto o da un modello che lo contiene, usare lo stesso nome del binding di cui si desidera eseguire l'override.
    OverwriteSe true, il codice esistente viene sovrascritto.
    Target NameNome del file generato.

    È possibile inserire in questa stringa espressioni quali {Name} o {Owner.Name}. Ad esempio, è possibile scrivere {Owner.Name}_{Name}. L'espressione viene valutata sull'elemento del modello e può usare proprietà di elementi, ma non metodi. Per individuare le proprietà che possono essere usate, verificare le proprietà dei tipi in Microsoft.VisualStudio.Uml. *. Important: L'espressione {Name} o {Owner.Name} può essere usata solo nella proprietà Target Name. Per modificare il nome della classe generata, è necessario modificare il modello. Per altre informazioni, vedere Scrittura di un modello di testo.
    Project PathSpecifica il percorso del progetto di Visual Studio che conterrà i file di output della trasformazione. Usare valori tipizzati per creare un nuovo progetto. Fare clic sul pulsante con i puntini di sospensione ([…]) per selezionare un progetto esistente.

    Se non esiste alcun progetto, verrà creato un nuovo progetto Libreria di classi C#.

    A questo scopo, è necessario digitare direttamente il progetto. È possibile includere macro di variabili di ambiente quali %ProgramFiles% o %LocalAppData%.
    Target DirectoryCartella in cui viene generato il file di destinazione. Il percorso è relativo alla cartella del progetto.

    È possibile usare l'espressione {PackageStructure} per inserire un percorso che corrisponde ai nomi dei pacchetti contenitore. Il valore predefinito è \GeneratedCode\{PackageStructure}. È anche possibile includere variabili di ambiente quali %TEMP% o %HomePath%. Important: L'espressione {PackageStructure} può essere usata solo nella proprietà Target Directory.
    Percorso del file di modelloModello che eseguirà la trasformazione.

    È possibile usare i modelli forniti o crearne di personalizzati. I modelli forniti sono disponibili nel percorso seguente:

    … \Programmi\Microsoft Visual Studio 12.0\Common7\IDE\Extensions\Microsoft\Architecture Tools\Extensibility\Templates\Text\
  5. È possibile collegare a un elemento il numero di binding desiderato.

È possibile scrivere modelli di testo personalizzati. I modelli di testo possono generare codice programma o qualsiasi altro tipo di file di testo.

Si consiglia di iniziare modificando copie dei modelli standard. È possibile copiare i modelli dai seguenti percorsi:

… \Programmi\Microsoft Visual Studio 12.0\Common7\IDE\Extensions\Microsoft\Architecture Tools\Extensibility\Templates\Text\

Per comprendere i modelli di testo, fare riferimento agli argomenti seguenti.

Per usare i modelli con il comando Genera codice, è necessario includere la direttiva Modeling. Ad esempio:

<#@ Modeling ElementType="Microsoft.VisualStudio.Uml.Classes.IClass" Processor="ModelingProcessor" #>

L'attributo ElementType definisce il tipo di elemento UML al quale si applica il modello.

Nel modello, this appartiene a una classe temporanea che dispone delle proprietà seguenti:

Le informazioni seguenti possono risultare utili durante la scrittura di un modello di testo. Queste informazioni sono descritte in dettaglio in Code Generation and T4 Text Templates.

  • È possibile impostare l'estensione del file risultante nella direttiva Output. Una direttiva Output è richiesta in ogni modello di testo.

  • Ad alcuni assembly viene fatto automaticamente riferimento nel modello. Tali assembly includono, ad esempio, System.dll e Microsoft.VisualStudio.Uml.Interfaces.dll.

    Per usare altri assembly nel codice programma generatore, è necessario usare una direttiva Assembly. Ad esempio:

    <#@ Assembly Name="%ProgramFiles%\Microsoft Visual Studio 12.0\Common7\IDE\PublicAssemblies\Microsoft.VisualStudio.ArchitectureTools.Extensibility.dll" #>

  • Alcuni spazi dei nomi quali System vengono importati automaticamente nel codice programma. Per altri spazi dei nomi, è possibile usare la direttiva Import in modo analogo a un'istruzione using. Ad esempio:

    <#@ Import Namespace="Microsoft.VisualStudio.Uml.Classes" #>

    <#@ Import Namespace="Microsoft.VisualStudio.ArchitectureTools.Extensibility.Uml" #>

  • Usare la direttiva Include per fare riferimento al testo di un altro file.

  • Le parti del modello racchiuse tra parentesi <# ... #> vengono eseguite dal comando Genera codice. Le parti del modello esterne a tali parentesi vengono copiate nel file risultante. È importante distinguere tra il codice generatore e il testo generato. Il testo generato può essere in qualsiasi linguaggio.

  • Le parti <#= Expressions #> vengono valutate e convertite in stringhe.

UML Class Diagrams: Reference
UML Class Diagrams: Guidelines
Generate files from a UML model

Mostra: