Como: Gerar código em diagramas de classe UML

Este Visual Studio 2010 do feature pack lhe permite criar código de elementos UML no Visual Studio 2010 Ultimate usando o Gerar código comando. Por padrão, o comando gera um tipo de C# para cada tipo que você seleciona em um diagrama de classe UML. Você pode modificar e estender esse comportamento modificando ou copiando os modelos de texto para geram o código. Você pode especificar o comportamento diferente para os tipos contidos em pacotes diferentes no seu modelo. Para obter mais informações, consulte Pacotes de funcionalidades de Visual Studio.

Importante

Se você substituiu o pacote de recurso de modelagem e a visualização de 2010 de Visual Studio com Visual Studio 2010 recurso Pack 2, você terá que remapear quaisquer modelos personalizados para projetos de geração de código no seguinte local: 10.0\Common7\IDE\Extensions\Microsoft\ de Visual Studio …\Microsoft<InsertVisualStudioFeaturePackName>\<InsertVisualStudioFeaturePackVersionNumber> Para obter mais informações, consulte Personalizando o comando de código gerar.

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

Como alternativa, se você deseja gerar o código na qual os arquivos gerados não possuem uma relação 1: 1 com elementos UML, você poderia considerar escrever modelos de texto são invocados com o Transformar todos os modelos de comando. 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 UML diagramas de classe 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 gerar

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

Para gerar um arquivo separado para cada elemento.

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

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

2. Em um diagrama de classe ou em Gerenciador de modelos UML, selecione os elementos que você deseja gerar código. Você pode selecionar um dos seguintes:

   • Um conjunto específico de elementos.

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

   • O diagrama para selecionar todos os elementos no diagrama.

3. Um elemento selecionado com o botão direito e clique em Gerar código.

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

   Clique em OK a menos que saiba o que você deseja alterar esses parâmetros.

   Para retornar para a caixa de diálogo mais tarde, clique com o botão direito do diagrama e clique em Configurar definições de geração de código padrão. Para obter mais informações, consulte Personalizando o comando de código gerar.

Arquivos que contêm o código de C# são gerados. No caso padrão, um arquivo é gerado para cada tipo e os arquivos são gerados em um projeto de biblioteca de classe C#. No entanto, você pode personalizar esse comportamento. Para obter mais informações, consulte Personalizando o comando de código gerar.

Alguns testes de validação são aplicadas ao modelo para garantir que ele pode ser traduzido para C#. Se esses testes falharem, uma mensagem de erro é exibida e a geração de código não é executada. Se você tiver criado um comando de menu de validação, o código não é gerado por qualquer elemento para o qual o comando validação falha. Para obter mais informações, consulte Como: Definir restrições de validação dos modelos UML.

Transformações de geração de código padrão

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

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

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

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

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

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

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

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

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

1. Clique com o botão direito do elemento em um diagrama ou em Gerenciador de modelos UMLe em seguida, clique em Propriedades.

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

   Dica

   Se os estereótipos C# não aparecerem, permitem que o C# perfil para o modelo ou para um pacote que contém os elementos de modelo no qual você está interessado. Selecione o pacote ou a raiz do modelo no Gerenciador de modelos UML. Em seguida na Propriedades janela, clique em perfile ative o perfil do C#.

3. Expanda o Estereótipos propriedade para ver as propriedades adicionais que podem ser definidas.

O Descrição propriedades de tipos, atributos, operações e associações são gravadas em <summary> comentários no código gerado. Elementos de comentário que são vinculados aos tipos são gravados em <remarks> comentários.

Variação de código gerado

O código gerado varia dependentes nas propriedades de cada tipo, o atributo ou operação. Por exemplo, se você definir o É abstrata propriedade de uma classe como true, em seguida, a abstract palavra-chave aparecerão sobre a classe de gerado. Se você definir a multiplicidade de um atributo para 0... *, e em seguida, a propriedade gerada terá uma IEnumerable<> tipo.

Além disso, cada estereótipo fornece várias propriedades que podem ser definidas. Esses valores são convertidos em palavras-chave no código C#. Por exemplo, se você definir a propriedade Is Static em uma classe, em seguida, a classe C# será static.

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

• Atributos CLR

• É parcial

• É estático

• Não é seguro

• Visibilidade de pacote

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

Personalizando o comando de código gerar

O Gerar código comando works, transformando os elementos de 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 ligações de modelo de texto. Uma ligação de modelo de texto Especifica qual modelo deve ser aplicado, onde deve ser colocada a saída gerada e outros parâmetros da Gerar código comando.

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

No entanto, você pode substituir e adicionar essas ligações padrão anexando-se em suas próprias ligações a pacotes, classes ou outros elementos. Uma ligação se aplica a todos os elementos contidos dentro do elemento ao qual está conectada. Por exemplo, se desejar que todos os tipos de dentro de um determinado pacote transformado por um conjunto de modelos diferentes, ou se a saída para uma pasta diferente, você pode anexar ligações de modelo para o pacote.

Para inspecionar as ligações do modelo anexadas a um elemento de modelo, clique nas reticências [...] na Ligações de modelo de texto a propriedade na janela Propriedades.

O Gerar código comando aplica-se modelos para cada elemento de modelo que você selecionou. Para cada elemento, o conjunto de modelos aplicada é o conjunto combinado de modelos que estão conectados a seus recipientes, até e incluindo a raiz do modelo.

Se duas ligações de modelo neste conjunto tem o mesmo nome, a ligação no recipiente menor substitui a ligação no recipiente maior. Por exemplo, a raiz do modelo tem uma ligação com o nome Class Template. Para ter seu próprio modelo aplicado ao conteúdo de um determinado pacote, definir sua própria associação ao modelo que tem o nome Class Template.

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

Observação

As ligações anexadas à raiz do modelo atuam como padrões para todos os elementos do modelo. Para ver essas ligações padrão, clique com o botão direito na superfície do diagrama e, em seguida, clique em Configurar definições de geração de código padrão. Como alternativa, selecione a raiz do modelo no Gerenciador de modelos UML e, em seguida, clique em […] na Ligações de modelo de texto propriedade. As ligações não aparecerá até que você tenha usado o Gerar código comando pelo menos uma vez. Ligações de modelo não podem ser anexadas a um diagrama.

Para anexar as ligações de modelo de texto para um pacote ou outro elemento de modelo

1. Em Gerenciador de modelos UML, um elemento de modelo com o botão direito e, em seguida, clique em Propriedades. Geralmente, você poderia anexar ligações de modelo de texto para um pacote ou para a raiz do modelo.

2. No Propriedades janela, clique no botão reticências ([…]) na Ligações de modelo de texto propriedade.

   O Ligações de modelo de texto caixa de diálogo aparece.

3. Clique em Add para criar uma nova ligação de modelo de texto.

   - ou -

   Clique em uma vinculação existente para editá-lo.

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

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

   Propriedade	Descrição
   Nome	Um nome para essa ligação. Para substituir uma ligação herdada de um pacote ou um modelo contendo, use o mesmo nome como a ligação que você deseja substituir.
   Substituir	Se verdadeiro, qualquer código existente será substituído.
   Nome de destino	O nome do arquivo que é gerado. Você pode inserir expressões nessa seqüência de caracteres, como {nome} ou {Owner.Name}. Por exemplo, você poderia escrever: {Owner.Name}_{Name}. A expressão é avaliada no elemento de modelo. Ele pode usar as propriedades de elementos, mas não métodos. Para localizar quais propriedades podem ser usadas, examine as propriedades de tipos em Microsoft.VisualStudio.Uml.*. Importante {Nome} ou {Owner.Name} pode ser usado apenas na Nome de destino propriedade.Para alterar o nome da classe gerada, você precisará modificar o modelo.Para obter mais informações, consulte a gravação de um modelo de texto.
   Caminho do projeto	Especifica o caminho para o Visual Studio project que contêm arquivos de saída. da transformação Use os valores digitados para criar um novo projeto. Clique no botão reticências ([…]) para selecionar um projeto existente. Um novo projeto será criado se ele não existe. Ele será um projeto de biblioteca de classe C#. Para fazer isso, você deve digitar diretamente no projeto. Você pode incluir macros de variável de ambiente como, por exemplo, % ProgramFiles % ou % LocalAppData %.
   Diretório de destino	A pasta na qual o arquivo de destino é gerado. O caminho é relativo à pasta do projeto. Você pode usar o {PackageStructure} a expressão para inserir um caminho que corresponde aos nomes dos pacotes que contêm. O valor padrão é \GeneratedCode\{PackageStructure}. Você também pode incluir variáveis de ambiente como, por exemplo, % TEMP % ou % HomePath %. Importante {PackageStructure} pode ser usado somente no O diretório de destino propriedade.
   Nome de arquivo de modelo	O modelo que irá executar a transformação. Você pode usar os modelos fornecidos ou criar seus próprios. Você pode encontrar os modelos fornecidos nos seguintes locais: Visualização de 2010 Visual Studio e modelagem Feature Pack: %LocalAppData%\Microsoft\VisualStudio\10.0\Extensions\Microsoft\<InsertVisualStudioFeaturePackName>\1.0\Templates\Text\ Dica Costuma ser % LocalAppData % Nome_da_unidade: \Users\nome de usuário\AppData\Local.No Windows XP e Windows 2003, use % AppData % em vez de % LocalAppData %. Visual Studio 2010 Feature Pack 2: 10.0\Common7\IDE\Extensions\Microsoft\Modeling\ de Visual Studio …\Microsoft<InsertVisualStudioFeaturePackName>\<InsertVisualStudioFeaturePackVersionNumber>

5. Você pode anexar quantas ligações a um elemento desejado.

Escrever um modelo de texto

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

Recomendamos que você inicie, modificando as cópias dos modelos padrão. Você pode copiar os modelos dos seguintes locais:

• Visualização de 2010 Visual Studio e modelagem Feature Pack: %LocalAppData%\Microsoft\VisualStudio\10.0\Extensions\Microsoft\<InsertVisualStudioFeaturePackName>\1.0\Templates\Text\

  Dica

  Costuma ser % LocalAppData % Nome_da_unidade: \Users\nome de usuário\AppData\Local. No Windows XP e Windows 2003, use % AppData % em vez de % LocalAppData %.

• Visual Studio 2010 Feature Pack 2: 10.0\Common7\IDE\Extensions\Microsoft\Modeling\ de Visual Studio …\Microsoft<InsertVisualStudioFeaturePackName>\<InsertVisualStudioFeaturePackVersionNumber>

Para compreender 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 do programa que lê o modelo. Para obter mais informações, consulte Modelos de texto T4 e de geração de código.

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

Para usar os modelos com o Gerar código de comando, você deve incluir a diretiva de modelagem. Por exemplo:

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

O ElementType atributo define o tipo de elemento UML, ao qual se aplica a este modelo.

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

• Element= UML IElement para que o 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. Esta é a visualização e o armazenamento de SDK de modelagem no qual o ModelStore UML é implementado. Para obter o UML IModelStore, use this.Element.GetModelStore().

Você pode achar os seguintes pontos útil enquanto você escreve um modelo de texto. Essa informação é descrita em detalhes em Modelos de texto T4 e de geração de código.

• Para depurar um modelo de texto, insira o seguinte dentro de um segmento de instrução: System.Diagnostics.Debugger.Launch();

• Você pode definir a extensão de nome de arquivo do resultado na Output diretiva. Um Output diretiva é necessária em cada modelo de texto.

• Alguns módulos (assemblies) é automaticamente referenciados pelo modelo. Esses conjuntos incluem, por exemplo, System. dll e Microsoft.VisualStudio.Uml.Interfaces.dll.

  Para usar outros assemblies em seu gerar código de programa, você deve usar um Assembly diretiva. Por exemplo:

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

• Alguns namespaces como System são automaticamente importados para o seu código de programa. Outros espaços para nome, você pode usar o Import diretriz da mesma maneira que você usaria uma using instrução. Por exemplo:

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

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

• Use o Include a diretiva para fazer referência o texto de outro arquivo.

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

• <#= Expressions #>são avaliados e convertidos em seqüências 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

Histórico de alterações

Date	History	Motivo
Dezembro de 2010	Conteúdo atualizado para Visual Studio 2010 recurso Pack 2.	Aprimoramento de informações.