Generar código a partir de diagramas de clases UML

Para generar código de Visual C# .NET a partir de diagramas de clases UML en Visual Studio Ultimate, use el comando Generar código. Este comando genera de forma predeterminada un tipo 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.

   Elija Aceptar a menos que desee cambiar estos parámetros.

   Para volver posteriormente a este cuadro de diálogo, abra el menú contextual del diagrama y, a continuación, elija Configuración predeterminada 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 establecer un estereotipo en un tipo u otro elemento

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

2. En la ventana Propiedades, elija la flecha de lista desplegable en la propiedad Estereotipos y, a continuación, active la casilla correspondiente al estereotipo que desea 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, elija Perfil y, después, 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 plantilla asociados a un elemento de modelo, elija los puntos suspensivos [...] en la propiedad Enlaces de plantilla de texto de 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.

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

1. En el Explorador de modelos UML, abra el menú contextual de un elemento de modelo y, a continuación, elija 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 el botón de puntos suspensivos ([…]) en la propiedad Enlaces de plantilla de texto.

   Aparece el cuadro de diálogo Text Template Bindings.

3. Elija Agregar para crear un nuevo enlace de plantilla de texto.

   O bien

   Elija un enlace existente para editarlo.

   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 el botón de 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 corresponda a los nombres de los paquetes contenedores. El valor predeterminado es \GeneratedCode\{PackageStructure}. También puede incluir variables de entorno como %TEMP% o %HomePath%. > [!IMPORTANT] > <P>{EstructuraPaquete} solo se puede usar en la propiedad <STRONG>Directorio de destino</STRONG>.</P>
   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 la siguiente ubicación: …\Archivos de programa\Microsoft Visual Studio 12.0\Common7\IDE\Extensions\Microsoft\Architecture Tools\Extensibility\Templates\Text\

   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 12.0\Common7\IDE\Extensions\Microsoft\Architecture Tools\Extensibility\Templates\Text\

   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 12.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