Agregar comandos y gestos a diagramas de capas
Puede definir comandos del menú contextual y controladores de gestos en los diagramas de capas de Visual Studio Ultimate. Puede empaquetar estas extensiones en una extensión de integración de Visual Studio(VSIX) que puede distribuir a otros usuarios Visual Studio.
Puede definir varios controladores de comandos y gestos en el mismo proyecto de Visual Studio si lo desea. También puede combinar varios proyectos de este tipo en un VSIX. Por ejemplo, podría definir un VSIX único que incluya comandos de capa, un lenguaje específico del dominio y comandos para los diagramas UML.
Nota
También puede personalizar la validación de arquitectura, en la que el código fuente de los usuarios se compara con los diagramas de capas.La validación de arquitectura debe definirse en un proyecto Visual Studio independiente.Puede agregarlo al mismo VSIX que otras extensiones.Para obtener más información, vea Agregar validación de arquitectura personalizada a diagramas de capas.
Requisitos para crear las extensiones de capa
Necesita tener instalado lo siguiente en el equipo donde desea desarrollar las extensiones de capa:
Visual Studio Ultimate
SDK de Visual Studio
SDK de visualización y modelado
Definir un comando o gesto en un nuevo VSIX
El método más rápido para crear una extensión consiste en usar la plantilla de proyecto. Esto coloca el código y el manifiesto de VSIX en el mismo proyecto.
Para definir una extensión mediante una plantilla de proyecto
Cree un proyecto en una nueva solución mediante el comando Nuevo proyecto del menú Archivo.
En el cuadro de diálogo Nuevo proyecto, en Proyectos de modelado, seleccione Layer Designer Command Extension (Extensión de comandos del diseñador de capas) o Layer Designer Gesture Extension (Extensión de gestos del diseñador de capas).
La plantilla crea un proyecto que contiene un pequeño ejemplo funcional.
Para probar la extensión, presione CTRL+F5 o F5.
Se iniciará una instancia experimental de Visual Studio. En esta instancia, cree un diagrama de capas. El comando o extensión de gesto debería funcionar en este diagrama.
Cierre la instancia experimental y modifique el código de muestra. Para obtener más información, vea Navegar y actualizar modelos de capas en el código del programa.
Puede agregar más controladores de comandos o de gestos al mismo proyecto. Para obtener más información, vea una de las secciones siguientes:
Definir un comando de menú
Definir un controlador de gestos
Para instalar la extensión en la instancia principal de Visual Studio o en otro equipo, busque el archivo .vsix en bin\*. Cópielo en el equipo donde desea instalarlo y, a continuación, haga doble clic en él. Para desinstalarlo, use el Administrador de extensiones en el menú Herramientas.
Agregar un comando o gesto a un VSIX independiente
Si desea crear un VSIX que contenga comandos, validadores de capas y otras extensiones, le recomendamos que cree un proyecto para definir VSIX y proyectos independientes para los controladores. Para obtener información sobre otros tipos de extensión de modelado, vea Ampliar modelos y diagramas UML.
Para agregar extensiones de nivel a un VSIX independiente
Cree un proyecto de biblioteca de clases en una solución de Visual Studio Ultimate nueva o en una existente. En el cuadro de diálogo Nuevo proyecto, haga clic en Visual C# y haga clic en Biblioteca de clases. Este proyecto contendrá clases de controlador de comandos o de gestos.
Nota
Puede definir más de una clase de controlador de comandos o de gestos en una biblioteca de clases, pero debe definir las clases de validación de capas en una biblioteca de clases independiente.
Identifique o cree un proyecto de VSIX en la solución. Un proyecto de VSIX contiene un archivo denominado source.extension.vsixmanifest. Para agregar una clase a un proyecto de VSIX:
En el cuadro de diálogo Nuevo proyecto, expanda Visual C#, haga clic en Extensibility (Extensibilidad) y, a continuación, en VSIX Project (Proyecto de VSIX).
En el Explorador de soluciones, haga clic con el botón secundario en el proyecto de VSIX y, a continuación, haga clic en Establecer como proyecto de inicio.
Haga clic en Select Editions (Seleccionar ediciones) y asegúrese de que Visual Studio Ultimate está activado.
En source.extension.vsixmanifest, en Activos, agregue el proyecto de controlador de comandos o de gestos como componente MEF.
En la pestaña Activos, elija Nuevo.
En Tipo, seleccione Microsoft.VisualStudio.MefComponent.
En Origen seleccione el proyecto de la solución actual y seleccione el nombre del proyecto de controlador de comandos o de gestos.
Guarde el archivo.
Vuelva al proyecto de controlador de comandos o de gestos, y agregue las siguientes referencias de proyecto.
Referencia |
Qué permite hacer |
|---|---|
Archivos de programa\Microsoft Visual Studio 12.0\Common7\IDE\Extensions\Microsoft\Architecture Tools\ExtensibilityRuntime\Microsoft.VisualStudio.ArchitectureTools.Extensibility.Layer.dll |
Crear y modificar las capas |
Microsoft.VisualStudio.Uml.Interfaces |
Crear y modificar las capas |
Microsoft.VisualStudio.ArchitectureTools.Extensibility |
Modificar formas en los diagramas |
System.ComponentModel.Composition |
Definir componentes mediante MEF (Managed Extensibility Framework) |
Microsoft.VisualStudio.Modeling.Sdk.12.0 |
Definir las extensiones de modelado |
Microsoft.VisualStudio.Modeling.Sdk.Diagrams.12.0 |
Actualizar formas y diagramas |
Edite el archivo de clases en el proyecto de biblioteca de clases de C# para que contenga el código de la extensión. Para obtener más información, vea una de las secciones siguientes:
Definir un comando de menú
Definir un controlador de gestos
Vea también Navegar y actualizar modelos de capas en el código del programa.
Para probar la característica, presione CTRL+F5 o F5. Se abre una instancia experimental de Visual Studio. En esta instancia, cree o abra un diagrama de capas.
Para instalar VSIX en la instancia principal de Visual Studio o en otro equipo, busque el archivo .vsix en el directorio bin del proyecto de VSIX. Cópielo en el equipo donde desea instalar VSIX. Haga doble clic en el archivo VSIX en el Explorador de Windows (Explorador de archivos en Windows 8).
Para desinstalarlo, use el Administrador de extensiones en el menú Herramientas.
Definir un comando de menú
Puede agregar más definiciones de comando de menú a un proyecto de gesto o comando existente. Cada comando se define con una clase que tiene las siguientes características:
La clase se declara de la siguiente forma:
[LayerDesignerExtension]
[Export(typeof(ICommandExtension))]
public class MyLayerCommand : ICommandExtension { ... }
El espacio de nombres y el nombre de la clase son insignificantes.
Los métodos que implementan ICommandExtension son los siguientes:
string Text {get;}- La etiqueta que aparece en el menú.
void QueryStatus(IMenuCommand command)- se le llama cuando el usuario hace clic con el botón secundario en el diagrama y determina si el comando debería estar visible y habilitado para la selección actual del usuario.
void Execute(IMenuCommand command)- se le llama cuando el usuario selecciona el comando.
Para determinar la selección actual, puede importar IDiagramContext:
[Import]
public IDiagramContext DiagramContext { get; set; }
...
DiagramContext.CurrentDiagram.SelectedShapes.Count()...
Para obtener más información, vea Navegar y actualizar modelos de capas en el código del programa.
Para agregar un nuevo comando, cree un nuevo archivo de código que contenga el siguiente ejemplo. A continuación, pruébelo y modifíquelo.
using Microsoft.VisualStudio.ArchitectureTools.Extensibility.Layer;
using Microsoft.VisualStudio.ArchitectureTools.Extensibility.Presentation;
using Microsoft.VisualStudio.Modeling.Diagrams.ExtensionEnablement;
using Microsoft.VisualStudio.Modeling.ExtensionEnablement;
using System.ComponentModel.Composition;
using System.Linq;
namespace MyLayerExtension // Change to your preference.
{
// This is a feature for Layer diagrams:
[LayerDesignerExtension]
// This feature is a menu command:
[Export(typeof(ICommandExtension))]
// Change the class name to your preference:
public class MyLayerCommand : ICommandExtension
{
[Import]
public IDiagramContext DiagramContext { get; set; }
[Import]
public ILinkedUndoContext LinkedUndoContext { get; set; }
// Menu command label:
public string Text
{
get { return "Duplicate layers"; }
}
// Called when the user right-clicks the diagram.
// Defines whether the command is visible and enabled.
public void QueryStatus(IMenuCommand command)
{
command.Visible =
command.Enabled = DiagramContext.CurrentDiagram
.SelectedShapes.Count() > 0;
}
// Called when the user selects the command.
public void Execute(IMenuCommand command)
{
// A selection of starting points:
IDiagram diagram = this.DiagramContext.CurrentDiagram;
ILayerModel lmodel = diagram.GetLayerModel();
foreach (ILayer layer in lmodel.Layers)
{ // All layers in model.
}
// Updates should be performed in a transaction:
using (ILinkedUndoTransaction t =
LinkedUndoContext.BeginTransaction("copy selection"))
{
foreach (ILayer layer in
diagram.SelectedShapes
.Select(shape=>shape.GetLayerElement())
.Where(element => element is ILayer))
{
ILayer copy = lmodel.CreateLayer(layer.Name + "+");
// Position the shapes:
IShape originalShape = layer.GetShape();
copy.GetShape().Move(
originalShape.XPosition + originalShape.Width * 1.2,
originalShape.YPosition);
}
t.Commit();
}
}
}
}
Definir un controlador de gestos
Un controlador de gestos responde cuando el usuario arrastra elementos hasta el diagrama de capas y cuando hace doble clic en cualquier parte del diagrama.
En el proyecto de VSIX existente de controlador de comandos o gestos, puede agregar un archivo de código que defina un controlador de gestos:
using Microsoft.VisualStudio.ArchitectureTools.Extensibility.Layer;
using Microsoft.VisualStudio.ArchitectureTools.Extensibility.Presentation;
using Microsoft.VisualStudio.Modeling.Diagrams.ExtensionEnablement;
using Microsoft.VisualStudio.Modeling.ExtensionEnablement;
using System.ComponentModel.Composition;
using System.Linq;
namespace MyLayerExtensions // change to your preference
{
[LayerDesignerExtension]
[Export(typeof(IGestureExtension))]
public class MyLayerGestureHandler : IGestureExtension
{
}
}
Observe los siguientes aspectos sobre los controladores de gestos:
Los miembros de IGestureExtension son los siguientes:
OnDoubleClick: se le llama cuando el usuario hace doble clic en cualquier parte en el diagrama.
CanDragDrop: se le llama repetidamente cuando el usuario mueve el mouse mientras arrastra un elemento al diagrama. Debe funcionar rápidamente.
OnDragDrop: se le llama cuando el usuario coloca un elemento en el diagrama.
El primer argumento de cada método es IShape, a partir del cual puede obtener el elemento de capa. Por ejemplo:
public void OnDragDrop(IShape target, IDataObject data) { ILayerElement element = target.GetLayerElement(); if (element is ILayer) { // ... } }Ya se han definido los controladores para algunos tipos de elemento arrastrado. Por ejemplo, el usuario puede arrastrar los elementos del Explorador de soluciones a un diagrama de capas. No puede definir un controlador de arrastre para estos tipos de elemento. En estos casos, no se invocarán los métodos DragDrop.
Para obtener más información sobre cómo descodificar otros elementos cuando se arrastran al diagrama, vea Cómo: Definir un controlador de gestos en un diagrama de modelado.
Vea también
Conceptos
Navegar y actualizar modelos de capas en el código del programa
Agregar validación de arquitectura personalizada a diagramas de capas