Cómo: Generar código a partir de diagramas de clases UML

En Visual Studio Ultimate se puede generar código a partir de los diagramas de clases UML mediante el comando de Generar código. De forma predeterminada, el comando genera un tipo de C# para cada tipo UML que seleccione.Puede modificar y extender este comportamiento si modifica o copia las plantillas de texto que generan código.Puede especificar un comportamiento diferente para los tipos contenidos en los diferentes paquetes de su modelo.

El comando Generar código es especialmente adecuado para generar código a partir de la selección de elementos del usuario y para generar un archivo para cada clase UML u otro elemento.Por ejemplo, la captura de pantalla muestra dos archivos de C# generados a partir de dos clases UML.

Como alternativa, si desea generar código en el que los archivos generados no tienen una relación de 1:1 con los elementos UML, podría considerar la posibilidad de escribir plantillas de texto que se invocan con el comando Transformar todas las plantillas.Para obtener más información sobre ese método, vea Cómo: Generar archivos a partir de un modelo UML.

Para obtener más información sobre los diagramas de clases UML en Visual Studio Ultimate, vea los temas siguientes:

• Diagramas de clases de UML: Referencia

• Diagramas de clases de UML: Instrucciones

Usar el comando Generar código

En el siguiente procedimiento se describe el comportamiento predeterminado del comando Generar código:

Para generar un archivo independiente para cada elemento

1. Cree un modelo de UML que contenga clases.Puede ser conveniente aplicar estereotipos a los elementos del modelo.

   Para obtener más información, vea Transformaciones de generación de código predeterminadas.

2. En un diagrama de clases o en el Explorador de modelos UML, seleccione los elementos a partir de los que desea generar código.Puede seleccionar uno de los siguientes:

   • Un conjunto concreto de elementos.

   • Un paquete o el modelo, para generar el código a partir del contenido.

   • El diagrama, para seleccionar todos sus elementos.

3. Abra el menú contextual de un elemento seleccionado y, a continuación elija Generar código.

   La primera vez que usa Generar código en un modelo determinado, aparece un cuadro de diálogo.Este cuadro de diálogo le permite editar los parámetros de generación de código del modelo.

   Haga clic en Aceptar a menos que desee cambiar estos parámetros.

   Para volver posteriormente a este cuadro de diálogo, abra el menu contextual para el diagrama y, a continuación, haga clic en Configure Default Code Generation Settings (Configurar los valores predeterminados de generación de código).Para obtener más información, vea Personalizar el comando Generar código.

Se generan archivos que contienen el código de C#.En el caso predeterminado, se genera un archivo para cada tipo y los archivos se generan en un proyecto de biblioteca de clases de C#.No obstante, puede personalizar este comportamiento.Para obtener más información, vea Personalizar el comando Generar código.

Se aplican al modelo algunas pruebas de validación para asegurarse de que se puede traducir a C#.Si se produce un error en las pruebas, se muestra un mensaje de error y no se realiza la generación de código.Si ha creado un comando de menú de validación, no se genera código para ningún elemento cuyo comando de validación produzca errores.Para obtener más información, vea Cómo: Definir restricciones de validación para modelos UML.

Transformaciones de generación de código predeterminadas

En esta sección se resumen los resultados obtenidos del comando Generar código, a menos que personalice el comando.Para obtener más información, vea Personalizar el comando Generar código.

• Se genera un tipo de C# para cada tipo seleccionado en el modelo de UML.Cada tipo se coloca en un archivo de código independiente bajo la carpeta GeneratedCode.

• Si el tipo UML está incluido en un paquete, el tipo de C# generado se coloca dentro de un espacio de nombres y el archivo se genera en una carpeta que tiene el mismo nombre que el espacio de nombres.

• Se genera una propiedad de C# para cada Attribute de una clase UML.

• Se genera un método de C# para cada Operation de un tipo UML.

• Se genera un campo de C# para cada asociación navegable en la que participa la clase.

Si agrega un estereotipo a cada tipo UML, puede controlar más propiedades del tipo de C# generado.

Para crear este tipo de C#	Dibuje este tipo UML	Aplique este estereotipo
Clase	Clase	<ninguno> o Clase de C#
Interfaz	Interfaz	<ninguno> o Interfaz de C#
Enumeración	Enumeración	<ninguno> o C# enum
Delegado	Clase	Delegado de C#
Struct	Clase	C# struct

Para establecer un estereotipo en un tipo u otro elemento

1. Abra el menú contextual para un elemento en un diagrama o en Explorador de modelos UML y, a continuación, elija Propiedades.

2. En la ventana Propiedades, haga clic en la flecha de la lista desplegable en la propiedad Stereotypes (Estereotipos) y, a continuación, active la casilla correspondiente al estereotipo que desee aplicar.

   Sugerencia
   Si no aparecen los estereotipos de C#, habilite el perfil de C# para el modelo o para un paquete que contiene los elementos del modelo en los que está interesado.Seleccione el paquete o la raíz del modelo en el Explorador de modelos UML.A continuación, en la ventana Propiedades, haga clic en Perfil y, a continuación, habilite el perfil de C#.

3. Expanda la propiedad Stereotypes (Estereotipos) para ver las propiedades adicionales que puede establecer.

Las propiedades Descripción de los tipos, atributos, operaciones y asociaciones se escriben en comentarios <summary> en el código generado.Marque como comentario los elementos vinculados a los tipos que se escriben en los comentarios <remarks>.

Modificar el código generado

El código generado varía según las propiedades de cada tipo, atributo u operación.Por ejemplo, si establece la propiedad Is Abstract (Abstracto) de una clase en true, aparecerá la palabra clave abstract en la clase generada.Si establece la Multiplicity (Multiplicidad) de un atributo en 0.. *, la propiedad generada tendrá un tipo IEnumerable<>.

Además, cada estereotipo proporciona varias propiedades adicionales que puede establecer.Estos valores se traducen a las palabras clave adecuadas en el código de C#.Por ejemplo, si establece la propiedad Is Static en una clase, la clase de C# será static.

Para establecer estas propiedades adicionales, seleccione la clase u otro elemento en el diagrama.En la ventana Propiedades, expanda Stereotypes (Estereotipos) y, a continuación, expanda el estereotipo de C#, por ejemplo, Clase de C.En las clases, estas propiedades adicionales incluyen:

• Atributos de CLR

• Is Partial

• Is Static

• Is Unsafe

• Package Visibility

Cada atributo y operación tiene también propiedades de estereotipo que puede establecer.Si no ve las propiedades en un nuevo atributo, ejecute Generar código.

Personalizar el comando Generar código

El comando Generar código funciona transformando los elementos del modelo mediante un conjunto de plantillas de texto.Para obtener más información acerca de las plantillas de texto, vea Generación de código y plantillas de texto T4).

Las plantillas se especifican en un conjunto de enlaces de plantilla de texto.Un enlace de plantilla de texto especifica qué plantilla se debería aplicar, dónde se debería colocar el resultado generado y otros parámetros del comando Generar código.

Al ejecutar por primera vez el comando Generar código en un modelo determinado, se adjunta un conjunto predeterminado de enlaces de plantilla a la raíz del modelo.Estos enlaces se aplican a todos los elementos en el modelo.

Sin embargo, puede invalidarlos y agregarlos a estos enlaces predeterminados si adjunta sus propios enlaces a los paquetes, clases u otros elementos.Un enlace se aplica a todos los elementos contenidos dentro del elemento al que se adjunta.Por ejemplo, si desea que todos los tipos dentro de un paquete determinado se transformen mediante un conjunto diferente de plantillas o se generen en una carpeta diferente, puede adjuntar los enlaces de plantilla al paquete.

Para inspeccionar los enlaces de la plantilla adjuntos a un elemento del modelo, haga clic en los puntos suspensivos [...] en la propiedad Text Template Bindings (Enlaces de plantilla de texto) en la ventana Propiedades.

El comando Generar código aplica las plantillas a cada elemento del modelo seleccionado.Para cada elemento, el conjunto de plantillas aplicado es el conjunto combinado de plantillas que se adjuntan a sus contenedores, hasta la raíz del modelo, inclusive.

Si dos enlaces de plantilla de este conjunto tienen el mismo nombre, el enlace del contenedor menor invalida el del contenedor mayor.Por ejemplo, la raíz modelo tiene un enlace con el nombre Class Template.Para hacer que se aplique su propia plantilla al contenido de un paquete determinado, defina su propio enlace de plantilla con el nombre Class Template.

Se puede aplicar más de una plantilla a un elemento modelo.Puede generar más de un archivo a partir de cada elemento del modelo.

[!NOTA]

Los enlaces adjuntos a la raíz del modelo sirven como valores predeterminados para todos los elementos del modelo.Para ver estos enlaces predeterminados, abra el menú contextual para la superficie del diagrama y, a continuación, haga clic en Configure Default Code Generation Settings (Configurar valores predeterminados de generación de código).Alternativamente, puede seleccionar la raíz del modelo en el Explorador de modelos UML y, a continuación, hacer clic en […] en la propiedad Text Template Bindings (Enlaces de plantilla de texto).Los enlaces no aparecerán hasta que haya usado el comando Generar código al menos una vez.Los enlaces de plantilla no se pueden adjuntar a un diagrama.

Para adjuntar los enlaces de plantilla de texto a un paquete u otro elemento del modelo

1. En Explorador de modelos UML, abra el menú contextual para un elemento del modelo y, a continuación Propiedades.Generalmente, adjuntaría los enlaces de plantilla de texto a un paquete o a la raíz del modelo.

2. En la ventana propiedades, elija los puntos suspensivos ([…]) en la propiedad Text Template Bindings.

   Aparece el cuadro de diálogo Text Template Bindings.

3. Haga clic en Agregar para crear un nuevo enlace de plantilla de texto.

   -O bien-

   Haga clic en un enlace existente para modificarlo.

   Cada enlace de plantilla define cómo se debería aplicar una plantilla especificada al elemento del modelo que seleccionó y otros elementos del modelo que contiene.

4. En el cuadro de diálogo, establezca las propiedades del enlace de plantilla de texto.

   Propiedad	Descripción
   Nombre	Nombre correspondiente a este enlace.Para invalidar un enlace heredado de un paquete contenedor o modelo, use el mismo nombre que el enlace que desea invalidar.
   Overwrite	Si es true, se sobrescribe cualquier código existente.
   Nombre de destino	Nombre del archivo que se generó. Puede insertar las expresiones en esta cadena como {Nombre} o {Propietario.Nombre}.Por ejemplo, podría escribir: {Propietario.Nombre}_{Nombre}.La expresión se evalúa en el elemento del modelo.Puede usar las propiedades de los elementos, pero no los métodos.Para buscar las propiedades que se pueden usar, examine las propiedades de tipos en Microsoft.VisualStudio.Uml.*. Importante {Nombre} o {Propietario.Nombre} solo se pueden usar en la propiedad Nombre de destino.Para cambiar el nombre de la clase generada, tiene que modificar la plantilla.Para obtener más información, vea Escribir una plantilla de texto.
   Ruta de acceso del proyecto	Especifica la ruta de acceso al proyecto de Visual Studio que contendrá los archivos de salida de la transformación.Use valores con tipo para crear un nuevo proyecto.Elija los puntos suspensivos ([…]) para seleccionar un proyecto existente. Se creará un nuevo proyecto si no existe uno.Será un proyecto de biblioteca de clases de C#. Para ello, debe escribir directamente el proyecto.Puede incluir macros de variable de entorno como %ProgramFiles% o %LocalAppData%.
   Directorio de destino	Carpeta en la que se genera el archivo de destino.La ruta de acceso es relativa a la carpeta de proyecto. Puede usar la expresión {PackageStructure} para insertar una ruta de acceso que corresponde a los nombres de los paquetes contenedores.El valor predeterminado es \GeneratedCode\{PackageStructure}.También puede incluir variables de entorno como %TEMP% o %HomePath%. Importante {EstructuraPaquete} solo se puede usar en la propiedad Directorio de destino.
   Ruta de acceso del archivo de plantilla	Plantilla que realizará la transformación. Puede usar las plantillas proporcionadas o crear otras propias.Puede buscar las plantillas proporcionadas en las siguientes ubicaciones: … \Archivos de programa\Microsoft Visual Studio 11.0\Common7\IDE\Microsoft\Herramientas\Extensibilidad\Plantillas\Texto de arquitectura\

5. Puede adjuntar tantos enlaces a un elemento como desee.

Escribir una plantilla de texto

Puede escribir a sus propias plantillas de texto.Las plantillas de texto pueden generar código de programa o cualquier otro tipo de archivo de texto.

Recomendamos comenzar por modificar las copias de las plantillas estándar.Puede copiar las plantillas de las ubicaciones siguientes:

… \Archivos de programa\Microsoft Visual Studio 11.0\Common7\IDE\Microsoft\Herramientas\Extensibilidad\Plantillas\Texto de arquitectura\

Para entender las plantillas de texto, consulte los siguientes temas.

• Una plantilla de texto es un prototipo del archivo resultante y contiene el texto resultante y el código de programa que lee el modelo.Para obtener más información, vea Generación de código y plantillas de texto T4.

• Para navegar por el modelo de UML en el código de programa, tiene que usar la API de UML.Para obtener más información, vea Cómo: Navegar por el modelo UML y Referencia de la API para la extensibilidad del modelado UML.

Para usar las plantillas con el comando Generar código, debe incluir la directiva de modelado.Por ejemplo:

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

El atributo ElementType define el tipo de elemento UML al que se aplica esta plantilla.

En la plantilla, this pertenece a una clase temporal que tiene las siguientes propiedades:

• Element = IElement de UML al que se aplica la plantilla.

• Errors: CompilerErrorCollection

• Host: ITextTemplatingEngineHost

• ModelBus: ModelBus.Para obtener más información, vea Cómo: Integrar modelos UML con otros modelos y herramientas.

• ProfileName = "C#Profile"

• ServiceProvider: IServiceProvider

• Session: TextTemplatingSession.

• Store: Store.Este es el almacén del SDK de visualización y modelado en el que se implementa el UML ModelStore.Para obtener el UML IModelStore, use this.Element.GetModelStore().

Puede encontrar útiles los siguientes puntos mientras escribe una plantilla de texto.Esta información se describe en detalle en Generación de código y plantillas de texto T4.

• Puede establecer la extensión de nombre de archivo del resultado en la directiva Output.Se requiere una directiva Output en cada plantilla de texto.

• La plantilla hace referencia automáticamente a algunos ensamblados.Estos ensamblados incluyen, por ejemplo, System.dll y Microsoft.VisualStudio.Uml.Interfaces.dll.

  Para usar otros ensamblados en el código generador del programa, debe usar una directiva Assembly.Por ejemplo:

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

• Algunos espacios de nombres como System se importan automáticamente al código de programa.Para otros espacios de nombres, puede usar la directiva Import de la misma manera que usaría una instrucción using.Por ejemplo:

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

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

• Use la directiva Include para hacer referencia al texto de otro archivo.

• El comando Generar código ejecuta las partes de la plantilla encerradas entre corchetes <# ... #>.Las partes de la plantilla que están fuera de los corchetes se copian en el archivo de resultados.Es importante distinguir entre el código generador y el texto generado.El texto generado puede estar en cualquier lenguaje.

• <#= Expressions #> se evalúa y se convierte en cadenas.

Vea también

Conceptos

Diagramas de clases de UML: Referencia

Diagramas de clases de UML: Instrucciones

Cómo: Generar archivos a partir de un modelo UML