Ajout de commandes et de mouvements aux diagrammes de couche
Définissez des commandes et des gestionnaires de mouvements de menu contextuel dans des diagrammes de couche dans Visual Studio Ultimate. Vous pouvez empaqueter ces extensions dans une extension d'intégration Visual Studio (VSIX) et les distribuer à d'autres utilisateurs de Visual Studio.
Vous pouvez définir plusieurs commandes et gestionnaires de mouvement dans le même projet Visual Studio. Vous pouvez également combiner plusieurs projets de ce type dans une extension VSIX. Par exemple, vous pouvez définir une extension VSIX unique qui inclut des commandes de couche, un langage spécifique au domaine et des commandes pour les diagrammes UML.
Notes
Personnalisez également la validation d'architecture, dans laquelle le code source des utilisateurs est comparé aux diagrammes de couche.Vous devez définir la validation d'architecture dans un projet séparé Visual Studio.Vous pouvez l'ajouter à la même extension VSIX que les autres extensions.Pour plus d'informations, consultez Ajout d'une validation d'architecture personnalisée aux diagrammes de couche.
Spécifications pour la création d'extensions de couche
Les composants suivants doivent être installés sur l'ordinateur sur lequel vous voulez développer vos extensions de couche :
Visual Studio Ultimate
SDK de Visual Studio
SDK de visualisation et modélisation
Définition d'une commande ou d'un mouvement dans une nouvelle extension VSIX
La méthode la plus rapide pour créer une extension consiste à utiliser le modèle de projet. Cela place le code et le manifeste VSIX dans le même projet.
Pour définir une extension à l'aide d'un modèle de projet
Créez un projet dans une nouvelle solution, en utilisant la commande Nouveau projet dans le menu Fichier.
Dans la boîte de dialogue Nouveau projet, sous Projets de modélisation, sélectionnez Layer Designer Gesture Extension (Extension de mouvement de concepteur de couche) ou Layer Designer Gesture Extension (Extension de mouvement de concepteur de couche).
Le modèle crée un projet qui contient un petit exemple.
Pour tester l'extension, appuyez sur CTRL+F5 ou F5.
Une instance expérimentale de Visual Studio démarre alors. Dans cette instance, créez un diagramme de couche. Votre extension de commande ou de mouvement doit fonctionner dans ce diagramme.
Fermez l'instance expérimentale et modifiez l'exemple de code. Pour plus d'informations, consultez Navigation et mise à jour des modèles de couche dans le code de programme.
Vous pouvez ajouter d'autres gestionnaires de commandes ou de mouvements au même projet. Pour plus d'informations, consultez l'une des sections suivantes :
Définition d'une commande de menu
Définition d'un gestionnaire de mouvements
Pour installer l'extension dans l'instance principale de Visual Studio ou sur un autre ordinateur, recherchez le fichier .vsix dans bin\*. Copiez-le sur l'ordinateur sur lequel vous souhaitez l'installer, puis double-cliquez dessus. Pour le désinstaller, utilisez le Gestionnaire d'extensions dans le menu Outils.
Ajout d'une commande ou d'un mouvement à un VSIX séparé
Si vous souhaitez créer un VSIX qui contient des commandes, des validateurs de couche et d'autres extensions, nous vous recommandons de créer un projet pour définir le VSIX et des projets séparés pour les gestionnaires. Pour plus d'informations sur les autres types d'extensions de modélisation, consultez l'article Extension de modèles et de diagrammes UML.
Pour ajouter des extensions de couche à un VSIX séparé
Créez un projet de bibliothèque de classes dans une solution Visual Studio Ultimate nouvelle ou existante. Dans la boîte de dialogue Nouveau projet, cliquez sur Visual C#, puis sur Bibliothèque de classes. Ce projet contient les classes de gestionnaires de mouvements ou de commandes.
Notes
Vous pouvez définir plusieurs classes de gestionnaires de mouvements ou de commandes dans une bibliothèque de classes, mais vous devez définir les classes de validation de couche dans une bibliothèque de classes séparée.
Identifiez ou créez un projet VSIX dans votre solution. Un projet VSIX contient un fichier nommé source.extension.vsixmanifest. Pour ajouter un projet VSIX :
Dans la boîte de dialogue Nouveau projet, développez Visual C#, cliquez sur Extensibilité, puis sur Projet VSIX.
Dans l'Explorateur de solutions, cliquez avec le bouton droit sur le projet VSIX, puis cliquez sur Définir comme projet de démarrage.
Cliquez sur Sélectionner des éditions et assurez-vous que Visual Studio Ultimate est sélectionné.
Dans source.extension.vsixmanifest, sous Composants, ajoutez le projet du gestionnaire de mouvements ou de commandes en tant que composant MEF.
Dans Composants.tab, choisissez Nouveau.
Dans Type, sélectionnez Microsoft.VisualStudio.MefComponent.
Sous Source, cliquez sur Projet dans la solution actuelle et sélectionnez le nom du projet de votre gestionnaire de mouvements ou de commandes.
Enregistrez le fichier.
Revenez au projet du gestionnaire de mouvements ou de commandes et ajoutez les références de projet suivantes.
Référence |
Actions autorisées |
|---|---|
Program Files\Microsoft Visual Studio 12.0\Common7\IDE\Extensions\Microsoft\Architecture Tools\ExtensibilityRuntime\Microsoft.VisualStudio.ArchitectureTools.Extensibility.Layer.dll |
Créer et modifier des couches |
Microsoft.VisualStudio.Uml.Interfaces |
Créer et modifier des couches |
Microsoft.VisualStudio.ArchitectureTools.Extensibility |
Modifier des formes sur les diagrammes |
System.ComponentModel.Composition |
Définir des composants à l'aide de Managed Extensibility Framework (MEF) |
Microsoft.VisualStudio.Modeling.Sdk.12.0 |
Définir des extensions de modélisation |
Microsoft.VisualStudio.Modeling.Sdk.Diagrams.12.0 |
Mettre à jour des formes et des diagrammes |
Modifiez le fichier de classe dans le projet de bibliothèque de classes C# pour qu'il contienne le code de votre extension. Pour plus d'informations, consultez l'une des sections suivantes :
Définition d'une commande de menu
Définition d'un gestionnaire de mouvements
Voir aussi Navigation et mise à jour des modèles de couche dans le code de programme.
Pour tester la fonctionnalité, appuyez sur CTRL+F5 ou F5. Une instance expérimentale de Visual Studio s'ouvre alors. Dans cette instance, créez ou ouvrez un diagramme de couche.
Pour installer le VSIX dans l'instance principale de Visual Studio ou sur un autre ordinateur, recherchez le fichier .vsix dans le répertoire bin du projet VSIX. Copiez-le sur l'ordinateur sur lequel vous souhaitez installer le VSIX. Double-cliquez sur le fichier VSIX dans l'Explorateur Windows (Explorateur de fichiers dans Windows 8).
Pour le désinstaller, utilisez le Gestionnaire d'extensions dans le menu Outils.
Définition d'une commande de menu
Vous pouvez ajouter d'autres définitions de commande de menu dans un projet de commande ou de mouvement existant. Chaque commande est définie par une classe avec les caractéristiques suivantes :
La classe est déclarée comme suit :
[LayerDesignerExtension]
[Export(typeof(ICommandExtension))]
public class MyLayerCommand : ICommandExtension { ... }
L'espace de noms et le nom de la classe sont sans importance.
Les méthodes qui implémentent ICommandExtension sont les suivantes :
string Text {get;}- L'étiquette qui s'affiche dans le menu.
void QueryStatus(IMenuCommand command)- appelée lorsque l'utilisateur clique avec le bouton droit sur le diagramme, et détermine si la commande doit être visible et active pour la sélection actuelle de l'utilisateur.
void Execute(IMenuCommand command)- appelée lorsque l'utilisateur sélectionne la commande.
Pour déterminer la sélection actuelle, vous pouvez importer IDiagramContext :
[Import]
public IDiagramContext DiagramContext { get; set; }
...
DiagramContext.CurrentDiagram.SelectedShapes.Count()...
Pour plus d'informations, consultez Navigation et mise à jour des modèles de couche dans le code de programme.
Pour ajouter une nouvelle commande, créez un fichier de code qui contient l'exemple suivant. Ensuite, testez-le et modifiez-le.
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();
}
}
}
}
Définition d'un gestionnaire de mouvements
Un gestionnaire de mouvements répond lorsque l'utilisateur fait glisser des éléments sur le diagramme de couche, et lorsque l'utilisateur double-clique sur le diagramme.
Vous pouvez ajouter à votre projet VSIX du gestionnaire de mouvements ou de commandes existant, un fichier de code qui définit un gestionnaire de mouvements :
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
{
}
}
Notez les points suivants à propos des gestionnaires de mouvements :
Les membres de IGestureExtension sont les suivants :
OnDoubleClick - appelé lorsque l'utilisateur double-clique sur le diagramme.
CanDragDrop - appelé à plusieurs reprises lorsque l'utilisateur déplace la souris pour faire glisser un élément sur le diagramme. Cela doit fonctionner rapidement.
OnDragDrop - appelé lorsque l'utilisateur dépose un élément sur le diagramme.
Le premier argument de chaque méthode est IShape, dont vous pouvez obtenir l'élément de couche. Par exemple :
public void OnDragDrop(IShape target, IDataObject data) { ILayerElement element = target.GetLayerElement(); if (element is ILayer) { // ... } }Les gestionnaires de certains types d'éléments glissés sont déjà définis. Par exemple, l'utilisateur peut faire glisser des éléments de l'Explorateur de solutions vers un diagramme de couche. Vous ne pouvez pas définir de gestionnaire de glisser-déplacer pour ces types d'éléments. Dans ces situations, vos méthodes DragDrop ne seront pas appelées.
Pour plus d'informations sur le décodage d'autres éléments lorsqu'ils sont glissés sur le diagramme, consultez Comment : définir un gestionnaire de mouvements sur un diagramme de modélisation.
Voir aussi
Concepts
Navigation et mise à jour des modèles de couche dans le code de programme
Ajout d'une validation d'architecture personnalisée aux diagrammes de couche
Comment : définir et installer une extension de modélisation