Partager via

Intégrer des modèles en utilisant Visual Studio ModelBus

  • Article

Visual Studio ModelBus fournit une méthode pour créer des liens entre les modèles, et entre d’autres outils et les modèles. Par exemple, vous pouvez lier des modèles DSL et des modèles UML. Vous pouvez créer un ensemble intégré de DSL.

Avertissement

L’extension Visual Studio ModelBus, décrite dans cet article, n’est plus disponible en téléchargement. Toutefois, ces instructions fonctionnent toujours pour les utilisateurs qui ont déjà installé cette extension.

ModelBus vous permet de créer une référence unique à un modèle ou à un élément spécifique à l'intérieur d'un modèle. Cette référence peut être stockée en dehors du modèle : dans un élément d'un autre modèle, par exemple. Quand, par la suite, un outil veut obtenir l’accès à l’élément, l’infrastructure ModelBus charge le modèle approprié et renvoie l’élément. Si vous le désirez, vous pouvez afficher le modèle pour l'utilisateur. Si le fichier n’est pas accessible à son emplacement précédent, ModelBus demande à l’utilisateur de le rechercher. Si l’utilisateur trouve le fichier, ModelBus corrige toutes les références au fichier.

Notes

Dans l’implémentation de Visual Studio actuelle de ModelBus, les modèles liés doivent être des éléments de la même solution Visual Studio.

Pour plus d’informations sur l’extension ModelBus, consultez les ressources suivantes :

Notes

Le composant Transformation de modèle de texte est automatiquement installé dans le cadre de la charge de travail Développement d’extensions Visual Studio. Vous pouvez aussi l’installer à partir de l’onglet Composants individuels de Visual Studio Installer, sous la catégorie SDK, bibliothèques et frameworks. Installez le composant Modeling SDK à partir de l’onglet Composants individuels.

Fournir l’accès à un DSL

Avant de créer les références ModelBus à un modèle ou à ses éléments, définissez un ModelBusAdapter pour le DSL. Le moyen le plus simple d’en définir un est d’utiliser l’extension Visual Studio ModelBus, qui ajoute des commandes au Concepteur DSL.

Pour exposer une définition DSL à ModelBus

  1. Ouvrez le fichier de définition DSL. Cliquez avec le bouton droit sur l’aire de conception, puis sélectionnez Activer ModelBus.

  2. Dans la boîte de dialogue, choisissez Je veux exposer ce DSL au ModelBus. Vous pouvez choisir les deux options si vous voulez que ce DSL expose ses modèles et consomme les références aux autres DSL.

  3. Sélectionnez OK. Un nouveau projet ModelBusAdapter est ajouté à la solution DSL.

  4. Si vous voulez accéder au DSL à partir d’un modèle de texte, vous devez modifier AdapterManager.tt dans le nouveau projet. Ignorez cette étape si vous voulez accéder au DSL à partir d'un autre code, tel que celui des commandes ou gestionnaires d'événements. Pour plus d’informations, consultez Utilisation de Visual Studio ModelBus dans un modèle de texte.

    1. Remplacez la classe de base AdapterManagerBase par VsTextTemplatingModelingAdapterManager.

    2. Vers la fin du fichier, insérez cet attribut devant la classe AdapterManager :

      [Microsoft.VisualStudio.Modeling.Integration.HostSpecific(HostName)]

    3. Dans le Gestionnaire de package NuGet du projet ModelBusAdapter, ajoutez un PackageReference NuGet à Microsoft.VisualStudio.TextTemplating.Modeling.

      Pour accéder au DSL à partir de modèles de texte et d'un autre code, vous avez besoin de deux adaptateurs, l'un modifié et l'autre non modifié.

  5. Sélectionnez Transformer tous les modèles.

  6. Régénérez la solution.

    ModelBus peut maintenant ouvrir des instances de ce DSL.

    Le dossier ModelBusAdapters\bin* contient les assemblys générés par les projets ModelBusAdapters et Dsl. Pour référencer ce DSL à partir d’un autre DSL, importez ces assemblys.

Garantir que les éléments peuvent être référencés

Par défaut, les adaptateurs Visual Studio ModelBus utilisent le GUID d’un élément pour l’identifier. Ces identificateurs doivent être conservés dans le fichier de modèle.

Pour que les ID d’élément soient conservés :

  1. Ouvrez DslDefinition.dsl.

  2. Dans l’Explorateur DSL, développez Comportement de sérialisation Xml, puis Données de classe.

  3. Pour chaque classe pour laquelle vous voulez créer des références ModelBus :

    Sélectionnez le nœud de la classe et, dans la fenêtre Propriétés, vérifiez que Sérialiser l’ID est défini sur true.

Sinon, si vous voulez utiliser les noms d’élément à la place des GUID pour identifier les éléments, vous pouvez remplacer des parties des adaptateurs générés. Remplacez les méthodes suivantes dans la classe d'adaptateur :

  • Remplacez GetElementId pour retourner l'identificateur que vous voulez utiliser. Cette méthode est appelée lors de la création de références.
  • Remplacez ResolveElementReference pour rechercher l’élément approprié à partir d’une référence ModelBus.

Accéder à un DSL à partir d’un autre DSL

Vous pouvez stocker des références ModelBus dans une propriété de domaine dans un DSL et écrire le code personnalisé qui les utilise. Vous pouvez aussi laisser l’utilisateur créer une référence ModelBus en sélectionnant un fichier de modèle, ainsi qu’un élément à l’intérieur du modèle.

Pour permettre à un DSL d’utiliser des références à un autre DSL, vous devez au préalable en faire un consommateur des références ModelBus.

Pour permettre à un DSL de consommer les références à un DSL exposé

  1. Dans le diagramme de Définition DSL, cliquez avec le bouton droit sur la partie principale du diagramme, puis sélectionnez Activer ModelBus.

  2. Dans la boîte de dialogue, sélectionnez Je veux activer ce modèle pour consommer des références ModelBus.

  3. Dans le projet Dsl du DSL consommateur, ajoutez les assemblys suivants aux références du projet. Ces assemblys (fichiers .dll) se trouvent dans le répertoire ModelBusAdapter\bin\* du DSL exposé.

    • Assembly DSL exposé, par exemple, Fabrikam.FamilyTree.Dsl.dll

    • Assembly d’adaptateur ModelBus exposé, par exemple, Fabrikam.FamilyTree.ModelBusAdapter.dll

  4. Ajoutez les assemblys .NET suivants aux références de projet du projet DSL consommateur.

    • Microsoft.VisualStudio.Modeling.Sdk.Integration.dll
    • Microsoft.VisualStudio.Modeling.Sdk.Integration.Shell.dll

Pour stocker un ModelBusReference dans une propriété de domaine

  1. Dans la définition DSL du DSL consommateur, ajoutez une propriété de domaine à une classe de domaine et définissez son nom.

  2. Dans la fenêtre Propriétés, avec la propriété de domaine sélectionnée, définissez Type sur ModelBusReference.

    À ce stade, le code du programme peut définir la valeur de la propriété. La valeur est en lecture seule dans la fenêtre Propriétés.

    Vous pouvez permettre aux utilisateurs de définir la propriété avec un éditeur ModelBusReference spécialisé. Il existe deux versions de cet éditeur ou sélecteur. La première permet aux utilisateurs de choisir un fichier de modèle et l’autre de choisir un fichier de modèle ainsi qu’un élément à l’intérieur du modèle.

Pour permettre à l’utilisateur de définir un ModelBusReference dans une propriété de domaine

  1. Cliquez avec le bouton droit sur la propriété de domaine, puis sélectionnez Modifier les propriétés spécifiques de ModelBusReference. La boîte de dialogue Sélecteur ModelBus s’ouvre.

  2. Sélectionnez le Type de ModelBusReference approprié vers un modèle ou un élément à l’intérieur d’un modèle.

  3. Dans la chaîne de filtre de la boîte de dialogue Fichier, entrez une chaîne telle que Family Tree files |*.ftree. Remplacez l’extension de fichier de votre DSL exposé.

  4. Si vous choisissez de référencer un élément dans un modèle, vous pouvez ajouter une liste de types que l’utilisateur peut sélectionner, par exemple, Company.FamilyTree.Person.

  5. Sélectionnez OK, puis Transformer tous les modèles dans la barre d’outils de l’Explorateur de solutions.

    Avertissement

    Si vous n’avez pas sélectionné de modèle ou d’entité valide, le bouton OK est sans effet, même s’il peut paraître activé.

  6. Si vous avez spécifié une liste de types cibles, comme Company.FamilyTree.Person, vous devez ajouter une référence d’assembly à votre projet DSL, en référençant la DLL du DSL cible, par exemple, Company.FamilyTree.Dsl.dll.

Pour tester un ModelBusReference

  1. Générez à la fois le DSL exposé et le DSL consommateur.

  2. Exécutez un des DSL en mode expérimental en appuyant sur F5 ou CTRL+F5.

  3. Dans le projet de débogage de l’instance expérimentale de Visual Studio, ajoutez les fichiers qui sont les instances de chaque DSL.

    Notes

    Visual Studio ModelBus peut uniquement résoudre les références aux modèles qui sont des éléments de la même solution Visual Studio. Par exemple, vous ne pouvez pas créer de référence à un fichier de modèle dans une autre partie de votre système de fichiers.

  4. Créez quelques éléments et liens dans l'instance du DSL exposé, puis enregistrez-les.

  5. Ouvrez une instance du DSL consommateur et sélectionnez un élément de modèle qui possède une propriété de référence de bus de modèles.

  6. Dans la fenêtre Propriétés, double-cliquez sur la propriété de référence ModelBus. La boîte de dialogue du sélecteur s'ouvre.

  7. Sélectionnez Parcourir et sélectionnez l’instance du DSL exposé.

    Si vous avez spécifié la référence ModelBus spécifique de l’élément, le sélecteur vous permet aussi de choisir un élément dans le modèle.

Créer des références dans le code de programme

Quand vous voulez stocker une référence à un modèle ou à un élément à l’intérieur d’un modèle, créez un ModelBusReference. Il existe deux sortes de ModelBusReference : les références de modèle et les références d'élément.

Pour créer une référence de modèle, vous avez besoin de l’AdapterManager du DSL dont le modèle est une instance, et du nom de fichier ou de l’élément de projet Visual Studio du modèle.

Pour créer une référence d'élément, vous avez besoin d'un adaptateur pour le fichier de modèle et de l'élément auquel vous voulez faire référence.

Notes

Avec Visual Studio ModelBus, vous pouvez créer des références uniquement à des éléments dans la même solution Visual Studio.

Importer les assemblys DSL exposés

Dans le projet consommateur, ajoutez des références de projet au DSL et aux assemblys ModelBusAdapter du DSL exposé.

Par exemple, imaginez que vous voulez stocker des références ModelBus dans les éléments d’un DSL MusicLibrary. Les références ModelBus référencent les éléments du DSL FamilyTree. Dans le nœud Références, dans le projet Dsl de la solution MusicLibrary, ajoutez des références aux assemblys suivants :

  • Fabrikam.FamilyTree.Dsl.dll. DSL exposé.

  • Fabrikam.FamilyTree.ModelBusAdapters.dll L’adaptateur ModelBus du DSL exposé.

  • Microsoft.VisualStudio.Modeling.Sdk.Integration

  • Microsoft.VisualStudio.Modeling.Sdk.Integration.Shell

    Ces assemblys sont disponibles dans le projet ModelBusAdapters du DSL exposé, sous *bin\**.

    Dans le fichier de code où vous créez les références, vous devez généralement importer ces espaces de noms :

// The namespace of the DSL you want to reference:
using Fabrikam.FamilyTree;  // Exposed DSL
using Fabrikam.FamilyTree.ModelBusAdapters;
using Microsoft.VisualStudio.Modeling.Integration;
using System.Linq;
...

Pour créer une référence à un modèle

Pour créer une référence de modèle, vous accédez à l'AdapterManager du DSL exposé et l'utilisez pour créer une référence au modèle. Vous pouvez spécifier un chemin d'accès du fichier ou un EnvDTE.ProjectItem.

À partir de la classe AdapterManager, vous pouvez obtenir un adaptateur, qui fournit l'accès aux éléments individuels du modèle.

Notes

Lorsque vous avez fini d'utiliser l'adaptateur, vous devez le supprimer. La solution la plus pratique pour y parvenir consiste à utiliser une instruction using. L'exemple suivant illustre ce comportement.

// The file path of a model instance of the FamilyTree DSL:
string targetModelFile = "TudorFamilyTree.ftree";
// Get the ModelBus service:
IModelBus modelBus =
    this.Store.GetService(typeof(SModelBus)) as IModelBus;
// Get an adapterManager for the target DSL:
FamilyTreeAdapterManager manager =
    (modelbus.GetAdapterManager(FamilyTreeAdapter.AdapterId)
     as FamilyTreeAdapterManager;
// or: (modelBus.FindAdapterManagers(targetModelFile).First())
// or could provide an EnvDTE.ProjectItem

// Create a reference to the target model:
// NOTE: the target model must be a file in this project.
ModelBusReference modelReference =
     manager.CreateReference(targetModelFile);
// or can use an EnvDTE.ProjectItem instead of the filename

// Get the root element of this model:
using (FamilyTreeAdapter adapter =
     modelBus.CreateAdapter(modelReference) as FamilyTreeAdapter)
{
  FamilyTree modelRoot = adapter.ModelRoot;
  // Access elements under the root in the usual way:
  foreach (Person p in modelRoot.Persons) {...}
  // You can create adapters for individual elements:
  ModelBusReference elementReference =
     adapter.GetElementReference(person);
  ...
} // Dispose adapter

Si vous souhaitez pouvoir utiliser la modelReference ultérieurement, vous pouvez la stocker dans une propriété de domaine qui possède le type externe ModelBusReference :

using Transaction t = this.Store.TransactionManager
    .BeginTransaction("keep reference"))
{
  artist.FamilyTreeReference = modelReference;
  t.Commit();
}

Pour permettre aux utilisateurs de modifier cette propriété de domaine, utilisez ModelReferenceEditor comme paramètre de l’attribut Editor. Pour plus d’informations, consultez Autoriser l’utilisateur à modifier une référence.

Pour créer une référence à un élément

L'adaptateur que vous avez créé pour le modèle peut être utilisé pour créer et résoudre les références.

// person is an element in the FamilyTree model:
ModelBusReference personReference =
  adapter.GetElementReference(person);

Si vous souhaitez pouvoir utiliser la elementReference ultérieurement, vous pouvez la stocker dans une propriété de domaine qui possède le type externe ModelBusReference. Pour permettre aux utilisateurs de la modifier, utilisez ModelElementReferenceEditor comme paramètre de l’attribut Editor. Pour plus d’informations, consultez Autoriser l’utilisateur à modifier une référence.

Résolution des références

Si vous avez une ModelBusReference (MBR), vous pouvez obtenir le modèle ou l'élément du modèle auquel elle fait référence. Si l'élément est présenté sur un diagramme ou une autre vue, vous pouvez ouvrir la vue et sélectionner l'élément.

Vous pouvez créer un adaptateur à partir d'une MBR. À partir de l'adaptateur, vous pouvez obtenir la racine du modèle. Vous pouvez aussi résoudre les MBR qui font référence à des éléments spécifiques à l'intérieur du modèle.

using Microsoft.VisualStudio.Modeling.Integration; ...
ModelBusReference elementReference = ...;

// Get the ModelBus service:
IModelBus modelBus =
    this.Store.GetService(typeof(SModelBus)) as IModelBus;
// Use a model reference or an element reference
// to obtain an adapter for the target model:
using (FamilyTreeAdapter adapter =
   modelBus.CreateAdapter(elementReference) as FamilyTreeAdapter)
   // or CreateAdapter(modelReference)
{
  // Get the root of the model:
  FamilyTree tree = adapter.ModelRoot;

  // Get a model element:
  MyDomainClass mel =
    adapter.ResolveElementReference<MyDomainClass>(elementReference);
  if (mel != null) {...}

  // Get the diagram or other view, if there is one:
  ModelBusView view = adapter.GetDefaultView();
  if (view != null)
  {
   view.Open();
   // Display the diagram:
   view.Show();
   // Attempt to select the shape that presents the element:
   view.SetSelection(elementReference);
  }
} // Dispose the adapter.

Pour résoudre des ModelBusReferences dans un modèle de texte

Le DSL auquel vous voulez accéder doit avoir un adaptateur ModelBus configuré pour être accessible par les modèles de texte. Pour plus d’informations, consultez Fournir l’accès à un DSL.

Généralement, vous accédez à un DSL cible en utilisant une référence ModelBus (MBR) stockée dans un DSL source. Par conséquent, votre modèle inclut la directive du DSL source, plus le code pour résoudre la MBR. Pour plus d’informations sur les modèles de texte, consultez Génération de code à partir d’un langage dédié.

<#@ template debug="true" hostspecific="true"
inherits="Microsoft.VisualStudio.TextTemplating.Modeling.ModelBusEnabledTextTransformation" #>
<#@ SourceDsl processor="SourceDslDirectiveProcessor" requires="fileName='Sample.source'" #>
<#@ output extension=".txt" #>
<#@ assembly name = "Microsoft.VisualStudio.Modeling.Sdk.Integration.11.0" #>
<#@ assembly name = "System.Core" #>
<#@ assembly name = "Company.CompartmentDragDrop.Dsl.dll" #>
<#@ assembly name = "Company.CompartmentDragDrop.ModelBusAdapter.dll" #>
<#@ import namespace="Microsoft.VisualStudio.Modeling.Integration" #>
<#@ import namespace="System.Linq" #>
<#@ import namespace="Company.CompartmentDragDrop" #>
<#@ import namespace="Company.CompartmentDragDrop.ModelBusAdapters" #>
<# // Get source root from directive processor:
  ExampleModel source = this.ExampleModel;
  // This DSL has an MBR in its root:
using (ModelBusAdapter adapter = this.ModelBus.CreateAdapter(source.ModelReference) as ModelBusAdapter)
  {
  ModelBusAdapterManager manager = this.ModelBus.FindAdapterManagers(this.Host.ResolvePath("Sample.compDD1")).FirstOrDefault();
  ModelBusReference modelReference =
    manager.CreateReference(this.Host.ResolvePath("Sample.compDD1"));

  // Get the root element of this model:
  using (CompartmentDragDropAdapter adapter =
     this.ModelBus.CreateAdapter(modelReference) as CompartmentDragDropAdapter)
  {
    ModelRoot root = adapter.ModelRoot;
#>
[[<#= root.Name #>]]
<#
  }
#>

Pour plus d’informations et pour suivre une procédure pas à pas, consultez Utilisation de Visual Studio ModelBus dans un modèle de texte

Sérialiser un ModelBusReference

Si vous voulez stocker une ModelBusReference (MBR) sous la forme d'une chaîne, vous pouvez la sérialiser :

string serialized = modelBus.SerializeReference(elementReference);
// Store it anywhere, then get it back again:
ModelBusReference elementReferenceRestored =
    modelBus.DeserializeReference(serialized, null);

Un MBR sérialisé de cette manière est indépendant du contexte. Si vous utilisez l’adaptateur ModelBus simple basé sur un fichier, le MBR contient un chemin de fichier absolu. Si les fichiers de modèle d’instance ne se déplacent jamais, cette sérialisation est suffisante. Toutefois, les fichiers de modèle sont généralement des éléments d’un projet Visual Studio. Vos utilisateurs veulent pouvoir déplacer la totalité du projet vers différentes parties du système de fichiers. Ils veulent aussi pouvoir garder le projet sous le contrôle de code source et l’ouvrir sur différents ordinateurs. Les noms des chemins d'accès doivent par conséquent être sérialisés par rapport à l'emplacement du projet qui contient les fichiers.

Sérialisation par rapport à un chemin de fichier spécifié

Une ModelBusReference contient un ReferenceContext, lequel est un dictionnaire où vous pouvez stocker des informations telles que le chemin d'accès par rapport auquel la sérialisation doit être effectuée.

Pour sérialiser par rapport à un chemin d'accès :

elementReference.ReferenceContext.Add(
   ModelBusReferencePropertySerializer.FilePathSaveContextKey,
   currentProjectFilePath);
string serialized = modelBus.SerializeReference(elementReference);

Pour extraire la référence de la chaîne :

ReferenceContext context = new ReferenceContext();
context.Add(ModelBusReferencePropertySerializer.FilePathLoadContextKey,
    currentProjectFilePath);
ModelBusReference elementReferenceRestored =
    modelBus.DeserializeReference(serialized, context);

Références ModelBus créées par d’autres adaptateurs

Les informations suivantes sont utiles si vous désirez créer votre propre adaptateur.

Une ModelBusReference (MBR) se compose de deux parties : l'en-tête MBR, désérialisé par le bus de modèles, et une partie propre à l'adaptateur et gérée par le gestionnaire de l'adaptateur spécifique. Cette approche vous permet de fournir votre propre format de sérialisation d’adaptateur. Par exemple, vous pouvez référencer une base de données plutôt qu'un fichier ou stocker des informations supplémentaires dans la référence de l'adaptateur. Votre propre adaptateur peut placer des informations supplémentaires dans le ReferenceContext.

Lorsque vous désérialisez une MBR, vous devez fournir un ReferenceContext, qui est alors stocké dans l'objet MBR. Lorsque vous sérialisez une MBR, le ReferenceContext stocké est utilisé par l'adaptateur pour aider à générer la chaîne. La chaîne désérialisée ne contient pas toutes les informations du ReferenceContext. Par exemple, dans l’adaptateur simple basé sur un fichier, le ReferenceContext contient un chemin de fichier racine. Le chemin n’est pas stocké dans la chaîne MBR sérialisée.

La désérialisation de la MBR s'effectue en deux étapes :

  • ModelBusReferencePropertySerializer est le sérialiseur standard qui gère l’en-tête MBR. Il utilise le conteneur de propriétés SerializationContext DSL standard, stocké dans le ReferenceContext à l'aide de la clé ModelBusReferencePropertySerializer.ModelBusLoadContextKey. En particulier, le SerializationContext doit contenir une instance du ModelBus.

  • Votre adaptateur ModelBus gère la partie spécifique à l'adaptateur de la MBR. Il peut utiliser les informations supplémentaires stockées dans le ReferenceContext de la MBR. L’adaptateur simple basé sur un fichier conserve les chemins de fichier racines en utilisant les clés FilePathLoadContextKey et FilePathSaveContextKey.

    Une référence d’adaptateur dans un fichier de modèle est désérialisée seulement quand elle est utilisée.

Créer un modèle

Création, ouverture et modification d’un modèle

Le fragment suivant est extrait de l’exemple State Machine du site web VMSDK. Il illustre l'utilisation des ModelBusReference pour créer et ouvrir un modèle, et pour obtenir le diagramme associé au modèle.

Dans cet exemple, le nom du DSL cible est StateMachine. Plusieurs noms en sont dérivés, tels que le nom de la classe de modèle et le nom du ModelBusAdapter.

using Fabrikam.StateMachine.ModelBusAdapters;
using Microsoft.VisualStudio.Modeling;
using Microsoft.VisualStudio.Modeling.Diagrams;
using Microsoft.VisualStudio.Modeling.Integration;
using Microsoft.VisualStudio.Modeling.Integration.Shell;
using Microsoft.VisualStudio.Modeling.Shell;
...
// Create a new model.
ModelBusReference modelReference =
   StateMachineAdapterManager    .CreateStateMachineModel(modelName, fileName);
//Keep reference of new model in this model.
using (Transaction t = ...)
{
  myModelElement.ReferenceProperty = modelReference;
  t.Commit();
}
// Get the ModelBus service from Visual Studio.
IModelBus modelBus = Microsoft.VisualStudio.Shell.Package.
    GetGlobalService(typeof(SModelBus)) as IModelBus;
// Get a modelbus adapter on the new model.
ModelBusAdapter modelBusAdapter;
modelBus.TryCreateAdapter(modelReference,
    this.ServiceProvider, out modelBusAdapter);
using (StateMachineAdapter adapter =
      modelBusAdapter as StateMachineAdapter)
{
    if (adapter != null)
    {
        // Obtain a Diagram from the adapter.
        Diagram targetDiagram =
           ((StandardVsModelingDiagramView)
                 adapter.GetDefaultView()
            ).Diagram;

        using (Transaction t =
             targetDiagram.Store.TransactionManager
                .BeginTransaction("Update diagram"))
        {
            DoUpdates(targetDiagram);
            t.Commit();
        }

        // Display the new diagram.
        adapter.GetDefaultView().Show();
    }
}

Valider les références

Le BrokenReferenceDetector teste toutes les propriétés de domaine d'un magasin qui peut contenir les ModelBusReference. Il appelle l'action que vous fournissez quand une action est trouvée. Ce test est utile pour les méthodes de validation. La méthode de validation suivante teste le magasin lors de la tentative d'enregistrement du modèle et signale les références rompues dans la fenêtre des erreurs :

[ValidationMethod(ValidationCategories.Save)]
public void ValidateModelBusReferences(ValidationContext context)
{
  BrokenReferenceDetector.DetectBrokenReferences(this.Store,
    delegate(ModelElement element, // parent of property
             DomainPropertyInfo property, // identifies property
             ModelBusReference reference) // invalid reference
    {
      context.LogError(string.Format(INVALID_REF_FORMAT,
             property.Name,
             referenceState.Name,
             new ModelBusReferenceTypeConverter().
                 ConvertToInvariantString(reference)),
         "Reference",
         element);
    });
}
private const string INVALID_REF_FORMAT =
    "The '{0}' domain property of this ReferenceState instance "
  + "named '{1}' contains reference value '{2}' which is invalid";

Actions exécutées par l'extension ModelBus

Les informations suivantes peuvent être utiles si vous faites une utilisation intensive de ModelBus.

L'extension ModelBus apporte les modifications suivantes dans votre solution DSL.

Quand vous cliquez avec le bouton droit sur le diagramme de définition DSL, sélectionnez Activer Modelbus, puis sélectionnez Activer ce DSL pour consommer le ModelBus :

  • Dans le projet DSL, une référence doit être ajoutée à Microsoft.VisualStudio.Modeling.Sdk.Integration.dll.

  • Dans la définition DSL, une référence de type externe est ajoutée : Microsoft.VisualStudio.Modeling.Integration.ModelBusReference.

    Vous pouvez voir la référence dans l’Explorateur DSL, sous Types de domaine. Pour ajouter manuellement des références de type externe, cliquez avec le bouton droit sur le nœud racine.

  • Un nouveau fichier de modèle est ajouté, Dsl\GeneratedCode\ModelBusReferencesSerialization.tt.

Quand vous définissez le type d’une propriété de domaine sur ModelBusReference, puis cliquez avec le bouton droit sur la propriété et sélectionnez Activer les propriétés spécifiques de ModelBusReference :

  • Plusieurs attributs CLR sont ajoutés à la propriété de domaine. Vous pouvez les voir dans le champ Attributs personnalisés de la fenêtre Propriétés. Dans Dsl\GeneratedCode\DomainClasses.cs, vous pouvez voir les attributs de la déclaration de propriété :

    [System.ComponentModel.TypeConverter(typeof(
Microsoft.VisualStudio.Modeling.Integration.ModelBusReferenceTypeConverter))]
[System.ComponentModel.Editor(typeof(
  Microsoft.VisualStudio.Modeling.Integration.Picker
  .ModelReferenceEditor // or ModelElementReferenceEditor
  ), typeof(System.Drawing.Design.UITypeEditor))]
[Microsoft.VisualStudio.Modeling.Integration.Picker
  .SupplyFileBasedBrowserConfiguration
  ("Choose a model file", "Target model|*.target")]

Quand vous cliquez avec le bouton droit sur le diagramme de la définition DSL, sélectionnez Activer Modelbus, puis Exposer ce DSL au ModelBus :

  • Un nouveau projet ModelBusAdapter est ajouté à la solution.

  • Une référence à ModelBusAdapter est ajoutée au projet DslPackage. ModelBusAdapter a une référence au projet Dsl.

  • Dans DslPackage\source.extention.tt, |ModelBusAdapter| est ajouté comme composant MEF.

Contenu connexe