Como: Gerar código a partir de diagramas de classe UML

Em Visual Studio Ultimate você pode gerar código de diagramas de classe de UML usando o comando de Gerar código . Por padrão, o comando gera um tipo de C# para cada tipo de UML que você seleciona.Você pode alterar e estender esse comportamento alterando ou copiando os modelos de texto que geram código.Você pode especificar o comportamento diferente para os tipos que estão contidos em pacotes diferentes no modelo.

O comando de Gerar código é especialmente adequado para a gerar o código de seleção do usuário de elementos, e a gerar um arquivo para cada classe de UML ou outro elemento.Por exemplo, o captura de tela a seguir mostra dois arquivos C# que foram gerados de duas classes de UML.

Como alternativa, se você desejar gerar o código em que os arquivos gerados não têm uma relação de 1:1 com os elementos de UML, você pode considerar gravar os modelos de texto que são chamados com o comando de Transformar Todos os Modelos .Para obter mais informações sobre esse método, consulte Como: gerar arquivos a partir de um modelo UML.

Para obter mais informações sobre diagramas de classe de UML em Visual Studio Ultimate, consulte os seguintes tópicos:

• Diagramas de classe UML: referência

• Diagramas de classe UML: diretrizes

Usando o comando de código de geração

O procedimento a seguir descreve o comportamento padrão de comando de Gerar código :

Para gerar um arquivo separado para cada elemento

1. Crie um modelo de UML que contém classes.Convém aplicar aos elementos estereótipos modelo.

   Para obter mais informações, consulte A geração de código se torna padrão.

2. Em um diagrama de classe ou em Modelo de UML Explorer, selecione os elementos de que você deseja gerar código.Você pode selecionar um destes procedimentos:

   • Um conjunto específico de elementos.

   • Um pacote ou modelo, para gerar código do seu conteúdo.

   • O diagrama, selecione todos os elementos no diagrama.

3. Abra o menu de atalho para um elemento selecionado, escolha Gerar código.

   Na primeira vez que você usa Gerar código em um modelo específico, uma caixa de diálogo aparece.Esta caixa de diálogo permite que você edite os parâmetros de geração de código de modelo.

   Escolha OK a menos que você saiba que você deseja alterar esses parâmetros.

   Para retornar posteriormente a esta caixa de diálogo, abra o menu de atalho para o diagrama, e escolha Configurar as configurações padrão de geração de código.Para obter mais informações, consulte Personalizando o comando de código de geração.

Os arquivos que contêm o código C# são gerados.Em casos padrão, um arquivo é gerado para cada tipo, e os arquivos são gerados em um projeto de biblioteca de classes C#.Entretanto, você pode personalizar esse comportamento.Para obter mais informações, consulte Personalizando o comando de código de geração.

Qualquer teste de validação são aplicados ao modelo para garantir que pode ser convertido para C#.Se esses testes falham, é exibida uma mensagem de erro e a geração de código não é executada.Se você criou um comando de menu de validação, o código não é gerado para qualquer elemento para o comando de validação falhar.Para obter mais informações, consulte Como: definir restrições de validação dos modelos UML.

A geração de código se torna padrão

Esta seção resume os resultados que são gerados pelo comando de Gerar código , a menos que você personalizar o comando.Para obter mais informações, consulte Personalizando o comando de código de geração.

• Um tipo de C# é gerado para cada tipo que você selecionou no modelo de UML.Cada tipo é colocado em um arquivo separado de código sob a pasta de GeneratedCode .

• Se o tipo de UML está contido em um pacote, o tipo gerado C# é colocado em um namespace, e o arquivo é gerado em uma pasta que tem o mesmo nome que o namespace.

• Uma propriedade C# é gerada para cada Attribute de uma classe de UML.

• Um método C# é gerado para cada Operation de um tipo de UML.

• Um campo de C# é gerado para cada associação navegável em que a classe participa.

Adicionando um estereótipo para cada tipo de UML, você pode controlar mais propriedades do tipo gerado C#.

Para criar este tipo de C#	Desenhar esse tipo de UML	Aplicar este estereótipo
Classe	Classe	<none> ou Classe C#
Interface	Interface	<none> ou Interface de C#
Enumeração	Enumeração	<none> ou Enum C#
Delegado	Classe	Representante C#
Estrutura	Classe	Estrutura de C#

Para definir um estereótipo em um tipo ou outro elemento

1. Abra o menu de atalho para o elemento no diagrama ou em um Modelo de UML Explorer, e escolha Propriedades.

2. Na janela de Propriedades , escolha a seta suspensa na propriedade de Estereótipos , selecione a caixa de seleção para o estereótipo que você deseja aplicar.

   Dica
   Se os estereótipos C# não aparecem, ative o perfil de C# para o modelo ou para um pacote que contém os elementos modelo em que você está interessado.Selecione o pacote ou a raiz do modelo no Modelo de UML Explorer.Na janela de Propriedades , escolha Perfil, e ativar o perfil C#.

3. Expanda a propriedade de Estereótipos para ver as propriedades adicionais que você pode definir.

As propriedades de Descrição de tipos, os atributos, as operações, e associações são gravadas para comentários de <summary> no código gerado.Os elementos de comentário que são associados aos tipos são gravados para comentários de <remarks> .

Variando o código gerado

O código gerado varia dependente nas propriedades de cada tipo, atributo ou operação.Por exemplo, se você definir a propriedade É abstrato de uma classe como true, então a palavra-chave abstract aparecerá na classe gerada.Se você definir Multiplicidade de um atributo a 0. *, a propriedade gerado terá um tipo de IEnumerable<> .

Além disso, cada estereótipo fornece várias propriedades adicionais que você pode definir.Esses valores são traduzidas para palavra-chave apropriado no código C#.Por exemplo, se você definir a propriedade Is Static em uma classe, a classe C# será static.

Para definir essas propriedades adicionais, selecione a classe ou outro elemento no diagrama.Na janela de propriedades, expanda Estereótiposem seguida, expanda o estereótipo C#, como Classe do C#.Para classes, essas propriedades adicionais incluem:

• Atributos CLR

• É parcial

• É estático

• Não é seguro

• Visibilidade de pacote

Cada atributo e operação também têm propriedades estereótipas que você pode definir.Se você não vir propriedades em um novo atributo, execute Gerar código.

Personalizando o comando de código de geração

O comando de Gerar código funciona transformando seus elementos modelo usando um conjunto de modelos de texto.Para obter mais informações sobre modelos de texto, consulte Modelos de texto T4 e de geração de código.

Os modelos são especificados em um conjunto de associações do modelo de texto.Uma associação de modelo de texto especifica que modelo deve ser aplicado, onde a saída gerados devem ser colocadas, e outros parâmetros de Gerar código comando.

Quando você executa o comando de Gerar código em um modelo específico, ele anexar um conjunto padrão de associações de modelo para a raiz do modelo.Essas associações aplicam-se a todos os elementos no modelo.

No entanto, você pode substituir e adicione a essas associações padrão anexando suas próprias associações a pacotes, classes, ou outros elementos.Uma associação se aplica a todos os elementos contidos dentro do elemento a que é anexada.Por exemplo, se você desejar que todos os tipos em um conjunto específico para ser ativado por um conjunto diferente de modelos, ou para ser saída para uma pasta diferente, você pode anexar associações de modelo ao pacote.

Verificar as associações de modelo anexadas a um elemento modelo, escolha as reticências [...] na propriedade de Associações do modelo de texto na janela propriedades.

O comando de Gerar código aplica modelos para cada elemento modelo que você selecionou.Para cada elemento, o conjunto de modelos aplicados é o conjunto de modelos que são anexados a seus recipientes, e incluindo até a raiz do modelo.

Se duas associações do modelo neste conjunto têm o mesmo nome, a associação no contêiner menor substitui a associação no contêiner maior.Por exemplo, a raiz de modelo tem uma associação com o nome Class Template.Para ter seu próprio modelo aplicado ao conteúdo de um conjunto específico, defina sua própria associação de modelo que tem o nome Class Template.

Mais de um modelo pode ser aplicado a um elemento modelo.Você pode gerar mais de um arquivo de cada elemento modelo.

Observação

As associações anexadas à raiz do modelo atuam como opções para todos os elementos no modelo.Para ver essas associações padrão, abra o menu de atalho para a superfície de diagrama, e escolha Configurar as configurações padrão de geração de código.Como alternativa, você pode selecionar a raiz do modelo no modelo de UML Explorer, e clique em […] na propriedade Associações do modelo de texto.As associações não aparecerão até que você use o comando de Gerar código pelo menos uma vez.As associações de modelo não podem ser anexadas a um diagrama.

Para anexar associações do modelo de texto a um pacote ou a outro modelar o elemento

1. No Modelo de UML Explorer, abra o menu de atalho para um elemento modelo, e escolha Propriedades.Geralmente, você anexaria associações do modelo de texto a um pacote ou à raiz do modelo.

2. Na janela Propriedades, escolha o botão de reticências ([…]) na propriedade Associações do modelo de texto.

   A caixa de diálogo Text associações de modelo aparecerá.

3. Escolha Adicionar para criar uma nova associação de modelo de texto.

   - ou -

   Escolha uma associação existente para editá-lo.

   Cada associação de modelo define como um modelo especificado deve ser aplicado ao elemento modelo que você selecionou, e outros elementos modelo que ele contém.

4. Na caixa de diálogo, defina as propriedades de associação de modelo de texto.

   Propriedade	Descrição
   Nome	Um nome para essa associação.Para substituir uma associação herdada de um pacote ou modelo recipiente, use o mesmo nome que a associação você deseja substituir.
   Substitua	Se verdadeiro, todo o código existente é substituído.
   Nome de destino	O nome do arquivo que é gerado. Você pode inserir expressões nesta cadeia de caracteres como {} Nome ou {} Owner.Name.Por exemplo, você pode escrever: {Owner.Name}_{Name}.A expressão é avaliada no elemento modelo.Pode usar propriedades de elementos, mas não métodos.Para localizar propriedades que podem ser usadas, a aparência nas propriedades de tipos em Microsoft.VisualStudio.Uml.*. Importante {} Nome ou {} Owner.Name podem ser usados somente na propriedade de Nome de destino .Para alterar o nome da classe gerada, você precisa modificar o modelo.Para obter mais informações, consulte Escrevendo um modelo de texto.
   Projeta o caminho	Especifica o caminho para o projeto de Visual Studio que conterá os arquivos de saída de transformação.Use valores tipados para criar um novo projeto.Escolha o botão de reticências ([…]) para selecionar um projeto existente. Um novo projeto será criado se ele não existir.Será um projeto de biblioteca de classes C#. Para fazer isso, você deve digitar o projeto diretamente.Você pode incluir macros da variável de ambiente como %ProgramFiles% ou %LocalAppData%.
   Diretório de destino	A pasta em que o arquivo de destino é gerado.O caminho é relativo à pasta do projeto. Você pode usar a expressão de {PackageStructure} para inserir um caminho que corresponde aos nomes dos pacotes recipiente.O valor padrão é \GeneratedCode\{PackageStructure}.Você também pode incluir variáveis de ambiente como %TEMP% ou %HomePath%. Importante {} PackageStructure pode ser usado apenas na propriedade de Diretório de destino .
   Caminho do arquivo de modelo	O modelo que será executado se transformar. Você pode usar os modelos oferecidos ou criar seus próprios.Você pode localizar os modelos oferecidos no seguinte local: … \ program files \ Microsoft Visual Studio 11,0 \ Common7 \ IDE \ extensões \ Microsoft \ ferramentas de arquitetura extensibilidade \ \ templates \ \ texto

5. Você pode anexar tantas associações a um elemento como você deseja.

Escrevendo um modelo de texto

Você pode escrever seus próprios modelos de texto.Os modelos de texto podem gerar código de programa ou qualquer outro tipo de arquivo de texto.

Recomendamos que você inicia alterando cópias dos modelos padrão.Você pode copiar os modelos dos seguintes locais:

… \ program files \ Microsoft Visual Studio 11,0 \ Common7 \ IDE \ extensões \ Microsoft \ ferramentas de arquitetura extensibilidade \ \ templates \ \ texto

Para entender os modelos de texto, consulte os tópicos a seguir.

• Um modelo de texto é um protótipo do arquivo resultante, e contém o texto resultante e o código de programa que lê o modelo.Para obter mais informações, consulte Modelos de texto T4 e de geração de código.

• Para navegar no modelo de UML no código de programa, você precisa usar UML API.Para obter mais informações, consulte Como: navegar o modelo UML e Referência da API de extensibilidade de modelagem UML.

Para usar os modelos com Gerar código comande, você deve incluir a diretiva modelando.Por exemplo:

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

O atributo de ElementType define o tipo de elemento de UML a que este modelo se aplica.

No modelo, this pertence a uma classe temporária que tenha as seguintes propriedades:

• Element = UML IElement ao modelo está sendo aplicado.

• Errors: CompilerErrorCollection

• Host: ITextTemplatingEngineHost

• ModelBus: ModelBus.Para obter mais informações, consulte Como: integrar modelos UML com outras ferramentas e modelos.

• ProfileName = “C#Profile”

• ServiceProvider: IServiceProvider

• Session: TextTemplatingSession.

• Store: Store.Este é o visualização e modelagem o armazenamento SDK em que UML ModelStore é implementado.Para obter UML IModelStore, use this.Element.GetModelStore().

Você pode localizar os seguintes pontos úteis quando você escrever um modelo de texto.Essa informação é descrito em detalhes em Modelos de texto T4 e de geração de código.

• Você pode definir a extensão de nome de arquivo do resultado na política de Output .Uma política de Output é necessário em cada modelo de texto.

• Alguns assemblies são referenciados automaticamente pelo modelo.Esses incluem assemblies, por exemplo, System.dll e Microsoft.VisualStudio.Uml.Interfaces.dll.

  Para usar outros assemblies no seu código de programa de geração, você deve usar uma política de Assembly .Por exemplo:

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

• Algumas namespaces como System são importadas automaticamente no seu código de programa.Para outros namespaces, você pode usar a política de Import da mesma maneira que você usaria uma declaração de using .Por exemplo:

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

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

• Use a política de Include para referenciar o texto de outro arquivo.

• As partes do modelo entre colchetes <# ... #> são executadas pelo comando de Gerar código .As partes do modelo fora dos colchetes são copiadas para o arquivo de resultado.É importante distinguir entre o código de geração e o texto gerado.O texto gerado pode estar em qualquer idioma.

• <#= Expressions #> é avaliado e convertido para cadeias de caracteres.

Consulte também

Conceitos

Diagramas de classe UML: referência

Diagramas de classe UML: diretrizes

Como: gerar arquivos a partir de um modelo UML