Intégration de modèles à l'aide de Visual Studio Modelbus

Article
02/19/2013

Visual Studio ModelBus fournit une méthode pour créer des liens entre les modèles et d'autres outils en modèles.Par exemple, vous pouvez lier des modèles et (DSL) des modèles UML de langage spécifique à un domaine.Vous pouvez créer un jeu intégré de langages spécifiques à un domaine.

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ées en dehors de le modèle, par exemple, dans un élément dans un autre modèle.Lorsque, à la possibilité ultérieure, un outil souhaite obtenir l'accès à l'élément, l'infrastructure de modèle de bus charge le modèle approprié et retourne l'élément.Si vous le souhaitez, vous pouvez afficher le modèle à l'utilisateur.Si le fichier n'est pas accessible dans leur emplacement précédent, ModelBus demandera à l'utilisateur de le trouver.si l'utilisateur recherche le fichier, ModelBus résoudra toutes les références à ce fichier.

[!REMARQUE]

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

Pour des informations supplémentaires et un exemple de code, consultez :

Fourniture de l'accès à un DÉSOLÉ

Avant de pouvoir créer des références ModelBus à un modèle ou à ses éléments, vous devez définir un ModelBusAdapter pour le langage spécifique à un domaine.La façon la plus simple est d'utiliser l'extension de mégabus de modèle de Visual Studio , qui ajoute des commandes au concepteur de langage spécifique à un domaine.

Pour exposer une définition DÉSOLÉ pour modéliser le bus

Téléchargez et installez l'extension de mégabus de modèle Visual Studio, à moins que vous ne l'ayez déjà installée.Pour plus d'informations, consultez Visualization and Modeling SDK.
Ouvrez le fichier de définition de langage spécifique à un domaine.Cliquez avec le bouton droit sur l'aire de conception puis cliquez sur Vérifiez Modelbus.
dans la boîte de dialogue, choisissez Je souhaite exposer ce DÉSOLÉ au ModelBus.Vous pouvez choisir les deux options si vous souhaitez que ce DÉSOLÉ pour exposer ses modèles et pour consommer des références à d'autres langages spécifiques à un domaine.
Cliquez sur OK.Un nouveau projet « ModelBusAdapter » est ajouté à la solution DÉSOLÉ.
Si vous souhaitez accéder au langage DÉSOLÉ d'un modèle de texte, vous devez modifier AdapterManager.tt dans le nouveau projet.Passez cette étape si vous souhaitez accéder au langage DÉSOLÉ d'un autre code tel que les commandes et gestionnaires d'événements.Pour plus d'informations, consultez Utilisation de Visual Studio ModelBus dans un modèle de texte.
1. modifiez la classe de base d'AdapterManagerBase à VsTextTemplatingModelingAdapterManager.
2. À la fin de le fichier, insérez cet attribut supplémentaire devant la classe AdapterManager :
  
  [Microsoft.VisualStudio.Modeling.Integration.HostSpecific(HostName)]
3. dans les références du projet de ModelBusAdapter, ajoutez Microsoft.VisualStudio.TextTemplating.Modeling.11.0.
Si vous souhaitez accéder au langage DÉSOLÉ des modèles de texte et d'un autre code, vous avez besoin de deux adaptateurs, un modifié et un non modifié.
cliquez sur Transformer tous les modèles.
Régénérez la solution.

Il est désormais possible pour ModelBus ouvre les instances de ce langage spécifique à un domaine.

Le dossier ModelBusAdapters\bin\* contient des assemblys générés par le projet d' Dsl et le projet d' ModelBusAdapters .Pour référencer ce DÉSOLÉ d'un autre langage DÉSOLÉ, vous devez importer ces assemblys.

S'assurer que les éléments peuvent être référencés

les adaptateurs deVisual Studio ModelBus utilisent le GUID d'un élément pour l'identifier, par défaut.Ces identificateurs doivent par conséquent être persistants dans le fichier de modèle.

Pour s'assurer que les ID d'élément sont rendus persistants

ouvrez DslDefinition.dsl.
Dans l'explorateur DÉSOLÉ, développez Comportement de sérialisation XML, puis Données de classes.
pour chaque classe à laquelle vous souhaitez créer le bus de modèle référence :

Cliquez sur le nœud de classe, puis dans la fenêtre Propriétés, assurez -vous que sérialisez l'identificateur est défini à true.

De même, si vous souhaitez utiliser des noms d'élément pour identifier des éléments au lieu de GUID, vous pouvez substituer des parties des adaptateurs générés.substituez les méthodes suivantes dans la classe d'adaptateur :

Substitution GetElementId pour retourner l'identificateur que vous souhaitez utiliser.cette méthode est appelée en créant des références.
Substitution ResolveElementReference pour rechercher l'élément correct d'une référence de modèle de bus.

Accès d'un DÉSOLÉ d'un autre langage DÉSOLÉ

Vous pouvez stocker des références de modèle de bus dans une propriété de domaine dans un langage spécifique à un domaine, et vous pouvez écrire du code personnalisé qui les utilise.Vous pouvez avez également laisser l'utilisateur créer une référence de modèle de bus en choisissant un fichier modèle et un élément à l'intérieur.

Pour permettre à un DÉSOLÉ pour utiliser des références à un autre langage DÉSOLÉ, vous devez d'abord en faire un consommateur des références de modèle de bus.

Pour permettre à un DÉSOLÉ pour consommer des références à un domaine (exposé

Dans le diagramme de définition DÉSOLÉ, cliquez avec le bouton droit sur la partie principale du diagramme puis cliquez sur Vérifiez Modelbus.
dans la boîte de dialogue, sélectionnez je souhaite permettre à ce modèle pour consommer des références de modèle de bus.
Dans le projet de domaine (DÉSOLÉ du consommateur, ajoutez les assemblys suivants aux références de projet.Vous trouverez ces assemblys (fichiers .dll) dans le ModelBusAdapter \bin\* directory of the exposed DSL.
- L'assembly exposé DÉSOLÉ, par exemple Fabrikam.FamilyTree.Dsl.dll
- l'assembly de modèle exposé d'adaptateur de bus, par exemple Fabrikam.FamilyTree.ModelBusAdapter.dll
Ajoutez les assemblys.NET suivants aux références de projet du projet consommateur DÉSOLÉ.
1. Microsoft.VisualStudio.Modeling.Sdk.Integration.11.0.dll
2. Microsoft.VisualStudio.Modeling.Sdk.Integration.Shell.11.0.dll

Pour stocker une référence de modèle de bus dans une propriété de domaine

Dans la définition de domaine (DÉSOLÉ du consommateur, ajoutez une propriété de domaine à une classe de domaine et définissez son nom.
dans la fenêtre Propriétés, avec la propriété de domaine sélectionnée, définissez Type à ModelBusReference.

À ce stade, le code de programme peut définir la valeur de propriété, mais il 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 spécifique de référence ModelBus.Il existe deux versions de ce éditeur ou sélecteur : il permet aux utilisateurs de choisir un fichier modèle, et l'autre permet aux utilisateurs de choisir un fichier modèle et un élément dans le modèle.

Pour permettre à l'utilisateur de définir une référence de modèle de bus dans une propriété de domaine

Cliquez avec le bouton droit sur la propriété de domaine puis cliquez sur propriétés spécifiques de ModelBusReference de modification.une boîte de dialogue s'ouvre.C'est le sélecteur de modèle de bus.
sélectionnez Type de ModelBusReferenceapproprié : d'un modèle ou d'un élément à l'intérieur d'un modèle.
Dans la chaîne de filtre de la boîte de dialogue Fichier, entrez une chaîne telle qu' Family Tree files |*.ftree.Subsitute l'extension de fichier de votre DÉSOLÉ exposé.
Si vous avez choisi 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.
Cliquez sur OK, puis cliquez sur Transformer tous les modèles dans la barre d'outils explorateur de solutions.

Attention

Si vous n'avez pas sélectionné un modèle ou une entité valide, le bouton OK n'aura aucun effet, même s'il peut sembler actif.
Si vous avez spécifié une liste de types de cible tels que Company.FamilyTree.Person, vous devez ajouter une référence d'assembly à votre projet DÉSOLÉ, référençant la DLL de la cible DÉSOLÉ, par exemple Company.FamilyTree.Dsl.dll

Attention
Si vous n'avez pas sélectionné un modèle ou une entité valide, le bouton OK n'aura aucun effet, même s'il peut sembler actif.

pour tester une référence de modèle de bus

Générez le langages spécifiques à un domaine exposé et consommateur.
Exécutez l'une des langages spécifiques à un domaine en mode expérimental en appuyant sur F5 ou CTRL+F5.
Dans le projet de débogage dans l'instance expérimentale de Visual Studio, ajoutez les fichiers qui sont des instances de chaque langage spécifique à un domaine.

[!REMARQUE]

Visual Studio ModelBus peut uniquement résoudre des références à des modèles qui sont des éléments dans la même solution de Visual Studio .Par exemple, vous ne pouvez pas créer une référence à un fichier de modèle dans une autre partie de votre système de fichiers.
Créez des éléments et des liens dans l'instance du langage DÉSOLÉ exposées, et enregistrez le fichier.
Ouvrez une instance du langage DÉSOLÉ consommateur, et sélectionnez un élément de modèle ayant une propriété de référence du modèle de bus.
Dans la fenêtre Propriétés, double-cliquez sur la propriété de référence du modèle de bus.La boîte de dialogue du sélecteur s'ouvre.
Cliquez sur Parcourir et sélectionnez l'instance de DÉSOLÉ exposé.

Le sélecteur vous permettent également de choisir un élément dans le modèle, si vous spécifiez le type de spécifique à l'élément de référence du modèle de bus.

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

Lorsque vous souhaitez stocker une référence à un modèle ou un élément dans un modèle, vous créez ModelBusReference.Il existe deux genres d' ModelBusReference: références de modèle et références d'un élément.

Pour créer une référence de modèle, vous avez besoin de l'AdapterManager du domaine (dont le modèle est une instance, et le nom de fichier ou de l'élément de projet de 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 que vous souhaitez faire référence.

[!REMARQUE]

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

Importez les assemblys exposés DÉSOLÉ

Dans le projet consommateur, ajoutez des références de projet au langage DÉSOLÉ et les assemblys de ModelBusAdapter du langage DÉSOLÉ exposé.

Par exemple, supposons que vous souhaitez stocker les références ModelBus dans les éléments d'un MusicLibrary DÉSOLÉ.Les références ModelBus se rapporteront aux éléments du FamilyTree DÉSOLÉ.Dans le projet d' Dsl de la solution de MusicLibrary, dans le nœud références, ajoutez des références aux assemblys suivants :

Fabrikam.FamilyTree.Dsl.dll - le DÉSOLÉ exposé.
Fabrikam.FamilyTree.ModelBusAdapters.dll - l'adaptateur ModelBus du langage DÉSOLÉ exposé.
Microsoft.VisualStudio.Modeling.Sdk.Integration.11.0
Microsoft.VisualStudio.Modeling.Sdk.Integration.Shell.11.0

Ces assemblys se trouvent dans le projet d' ModelBusAdapters du langage DÉSOLÉ exposées, sous bin\*.

Dans le fichier de code où vous créerez des 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 pour le langage DÉSOLÉ exposé, puis l'utiliser pour créer une référence au modèle.Vous pouvez spécifier un chemin d'accès, ou un EnvDTE.ProjectItem.

De l'AdapterManager, vous pouvez obtenir un adaptateur, qui permet d'accéder aux éléments individuels dans le modèle.

[!REMARQUE]

Vous devez préparer un adaptateur lorsque vous avez fini.La plupart de moyen pratique d'y parvenir consiste à utiliser une instruction d' 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 modelReference ultérieurement, vous pouvez la stocker dans une propriété de domaine qui a 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 dans l'attribut de l'éditeur.Pour plus d'informations, consultez Permettre à l'utilisateur de 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 elementReference ultérieurement, vous pouvez la stocker dans une propriété de domaine qui a le type externe ModelBusReference.Pour permettre aux utilisateurs de la modifier, utilisez ModelElementReferenceEditor comme paramètre dans l'attribut de l'éditeur.Pour plus d'informations, consultez Permettre à l'utilisateur de modifier une référence.

Résoudre les références

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

vous pouvez créer un adaptateur d'un MBR.de l'adaptateur, vous pouvez obtenir la racine du modèle.Vous pouvez également résoudre MBRs qui font référence à des éléments spécifiques dans le 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 les références de ModelBus dans un modèle de texte

Le langage DÉSOLÉ que vous souhaitez accéder doit avoir un adaptateur ModelBus qui a été configuré pour l'accès par les modèles de texte.Pour plus d'informations, consultez To provide access to a DSL.

En général, vous accéderez à une cible DÉSOLÉ à l'aide d'une référence de modèle de (MBR) bus stockées dans une source DÉSOLÉ.Votre modèle inclut par conséquent la directive de la source DÉSOLÉ, plus le code pour résoudre le MBR.Pour plus d'informations sur les modèles de texte, consultez Génération de code à partir d'un langage spécifique à un domaine.

<#@ 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 a 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 obtenir une procédure pas - à - pas, consultez l' Utilisation de Visual Studio ModelBus dans un modèle de texte

sérialiser un ModelBusReference

Si vous souhaitez stocker ModelBusReference (MBR) sous la forme de chaîne, vous pouvez la sérialisation :

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

Un MBR qui est sérialisé de cette façon est indépendant de contexte.si vous utilisez l'adaptateur simple de bus de modèle basé sur des fichiers, le MBR contient un chemin d'accès de fichier absolu.Cela est suffisant si les fichiers de modèle d'instance ne peuvent jamais.Toutefois, les fichiers de modèle sont généralement les éléments d'un projet de Visual Studio .Vos utilisateurs compteront pouvoir déplacer l'ensemble du projet à différentes parties du système de fichiers.Ils compteront également pouvoir conserver le projet sous le contrôle de code source et ouvrez -le sur des ordinateurs différents.Les noms de chemin d'accès ne doivent donc être sérialisés relatif à l'emplacement du projet qui contient les fichiers.

Sérialiser par rapport à un chemin d'accès de fichier spécifié

ModelBusReference contient ReferenceContext, qui est un dictionnaire dans lequel vous pouvez stocker des informations telles que le chemin d'accès relatif du fichier qu'il doit être sérialisé.

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

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

Pour récupérer la référence de la chaîne :

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

ModelBusReferences l'a créé par d'autres adaptateurs

les informations suivantes sont utiles si vous souhaitez créer votre propre adaptateur.

ModelBusReference (MBR) se compose de deux parties : l'en-tête de MBR, qui est désérialisé par le bus de modèle, et un spécifiques à l'adaptateur géré par le gestionnaire spécifique d'adaptateur.Cela 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 vous pouvez stocker les informations supplémentaires dans la référence de l'adaptateur.Votre propre adaptateur peut placer des informations supplémentaires dans ReferenceContext.

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

Le MBR est désérialisé en deux étapes :

ModelBusReferencePropertySerializer est le sérialiseur standard qui traite l'en-tête de MBR.Il utilise le conteneur des propriétés de la norme DÉSOLÉ SerializationContext , qui est stocké dans ReferenceContext à l'aide de ModelBusReferencePropertySerializer.ModelBusLoadContextKeyprincipal.En particulier, SerializationContext doit contenir une instance d' ModelBus.
Votre adaptateur ModelBus a affaire à la partie spécifique à la carte du MBR.Elle peut utiliser les informations supplémentaires stockées dans le ReferenceContext du MBR.L'adaptateur basé sur des fichiers simple conserve les chemins d'accès de fichier racine à l'aide de les clés FilePathLoadContextKeyet FilePathSaveContextKey.

Une référence d'adaptateur dans un fichier modèle est désérialisée uniquement lorsqu'elle est utilisée.

pour créer un modèle

La création, l'ouverture et la modification d'un modèle

Le fragment suivant est extrait de l'exemple de machine à états sur le site Web VMSDK.Il illustre l'utilisation de ModelBusReferences de créer et ouvrir un modèle, et d'obtenir le diagramme associé au modèle.

Dans cet exemple, le nom de la cible DÉSOLÉ est StateMachine.Plusieurs noms sont dérivés de lui, 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 des références

Le BrokenReferenceDetector teste toutes les propriétés de domaine dans un magasin qui peut contenir ModelBusReferences.Il s'appelle l'action qui fournissent où toute action est trouvée.Cela est particulièrement utile pour les méthodes de validation.La méthode suivante de validation teste le magasin sur une tentative d'enregistrer le modèle, et enregistre les références rompues dans la fenêtre d'erreur :

[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 ths ReferenceState instance "
  + "named '{1}' contains reference value '{2}' which is invalid";

Actions exécutées par l'extension ModelBus

Les informations suivantes ne sont pas essentielles, mais peuvent être utiles si vous utilisez beaucoup de ModelBus.

L'extension ModelBus apporte les modifications suivantes dans votre solution DÉSOLÉ.

Lorsque vous cliquez avec le bouton droit sur le schéma de définition DÉSOLÉ, cliquez sur Vérifiez Modelbus, puis sélectionnez Permettez à ce langage DÉSOLÉ pour consommer le ModelBus:

Dans le projet DÉSOLÉ, une référence est ajoutée à Microsoft.VisualStudio.Modeling.Sdk.Integration.11.0.dll
Dans la définition DÉSOLÉ, une référence externe de type est ajoutée : Microsoft.VisualStudio.Modeling.Integration.ModelBusReference.

vous pouvez voir la référence dans Explorateur DÉSOLÉ, sous types de domaine.Pour ajouter des références externes de type manuellement, cliquez avec le bouton droit sur le nœud racine.
un nouveau fichier modèle est ajouté, Dsl\GeneratedCode\ModelBusReferencesSerialization.tt.

Lorsque vous définissez le type d'une propriété de domaine à ModelBusReference, puis cliquez avec le bouton droit sur la propriété et cliquez sur Vérifiez les propriétés spécifiques de ModelBusReference:

Plusieurs attributs CLR sont ajoutés à la propriété de domaine.Vous pouvez les consulter dans le champ personnalisé d'attributs dans 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")]

Lorsque vous cliquez avec le bouton droit sur le schéma de définition DÉSOLÉ, cliquez sur Vérifiez ModelBus, puis sélectionnez Exposez ce DÉSOLÉ au ModelBus:

un nouveau projet ModelBusAdapter est ajouté à la solution.
une référence à ModelBusAdapter est ajoutée au projet d' DslPackage .ModelBusAdapter possède une référence au projet d' Dsl .
Dans DslPackage\source.extention.tt, |ModelBusAdapter| est ajouté en tant que composant MEF.

Partager via