Integrieren von Modellen mit Visual Studio ModelBus

Artikel
06/19/2023

Visual Studio ModelBus bietet eine Methode zum Erstellen von Links zwischen Modellen und von anderen Tools zu Modellen. Beispielweise könnten Sie DSL-Modelle (Domain-Specific Language, domänenspezifische Sprache) und UML-Modelle verbinden. Sie können einen integrierten Satz von DSLs erstellen.

Warnung

Die in diesem Artikel beschriebene Visual Studio ModelBus-Erweiterung steht nicht mehr zum Download zur Verfügung. Die Anweisungen richten sich an Benutzer*innen, die diese Erweiterung bereits installiert haben.

Mit ModelBus können Sie einen eindeutigen Verweis auf ein Modell oder ein bestimmtes Element in einem Modell erstellen. Dieser Verweis kann außerhalb des Modells gespeichert werden, beispielweise in einem Element eines anderen Modells. Wenn zu einem späteren Zeitpunkt ein Tool Zugriff auf das Element benötigt, wird das entsprechende Modell in der ModelBus-Infrastruktur geladen und das Element zurückgegeben. Bei Bedarf können Sie das Modell dem Benutzer zeigen. Kann am vorherigen Speicherort auf die Datei nicht zugegriffen werden, werden Benutzer*innen von ModelBus aufgefordert, nach der Datei zu suchen. Wird die Datei gefunden, aktualisiert ModelBus alle Verweise auf die Datei.

Hinweis

In der aktuellen Visual Studio-Implementierung von ModelBus müssen sich die verknüpften Modelle in derselben Visual Studio-Projektmappe befinden.

Weitere Informationen zur ModelBus-Erweiterung finden Sie unter:

Hinweis

Die Komponente Textvorlagentransformation wird automatisch als Teil der Workload Visual Studio-Erweiterungsentwicklung installiert. Sie können die Installation auch über die Registerkarte Einzelne Komponenten des Visual Studio-Installers unter der Kategorie SDKs, Bibliotheken und Frameworks durchführen. Installieren Sie die Komponente Modellierungs-SDK auf der Registerkarte Einzelne Komponenten.

Bereitstellen von Zugriff auf eine DSL

Bevor Sie ModelBus-Verweise auf ein Modell oder dessen Elemente erstellen können, müssen Sie einen ModelBus-Adapter für die DSL erstellen. Dies geht am einfachsten mit der Visual Studio ModelBus-Erweiterung, die dem DSL-Designer Befehle hinzufügt.

So machen Sie eine DSL-Definition für ModelBus verfügbar

Öffnen Sie die DSL-Definitionsdatei. Klicken Sie mit der rechten Maustaste auf die Entwurfsoberfläche, und klicken Sie dann auf ModelBus aktivieren.
Wählen Sie im Dialogfeld die Option Ich möchte diese DSL für ModelBus verfügbar machen aus. Sie können beide Optionen auswählen, wenn diese DSL Modelle verfügbar machen soll und Verweise auf andere DSLs nutzen soll.
Wählen Sie OK aus. Der DSL-Projektmappe wird ein neues ModelBusAdapter-Projekt hinzugefügt.
Wenn Sie auf die DSL über eine Textvorlage zugreifen möchten, müssen Sie im neuen Projekt die Datei AdapterManager.tt ändern. Überspringen Sie diesen Schritt, wenn Sie mit anderem Code wie Befehlen oder Ereignishandlern auf die DSL zugreifen möchten. Weitere Informationen finden Sie unter Verwenden von Visual Studio ModelBus in einer Textvorlage.
1. Ändern Sie die Basisklasse von AdapterManagerBase in VsTextTemplatingModelingAdapterManager.
2. Fügen Sie am Ende der Datei das folgende Attribut vor der Klasse AdapterManager ein:
  
  [Microsoft.VisualStudio.Modeling.Integration.HostSpecific(HostName)]
3. Fügen Sie im NuGet-Paket-Manager des Projekts ModelBusAdapter einen NuGet-Paketverweis auf Microsoft.VisualStudio.TextTemplating.Modeling hinzu.
  
  Wenn Sie auf die DSL über Textvorlagen und anderen Code zugreifen möchten, benötigen Sie einen geänderten und einen nicht geänderten Adapter.
Klicken Sie auf Alle Vorlagen transformieren.
Generieren Sie die Projektmappe neu.

ModelBus kann jetzt Instanzen dieser DSL öffnen.

Der Ordner ModelBusAdapters\bin* enthält die Assemblys, die von den Projekten Dsl und ModelBusAdapters erstellt wurden. Wenn Sie mit einer anderen DSL auf diese DSL verweisen möchten, müssen Sie diese Assemblys importieren.

Sicherstellen, dass auf Elemente verwiesen werden kann

Visual Studio ModelBus-Adapter identifizieren ein Element standardmäßig anhand seiner GUID. Daher müssen diese IDs in der Modelldatei erhalten bleiben.

So stellen Sie sicher, dass Element-IDs erhalten bleiben

Öffnen Sie die Datei DslDefinition.dsl.
Erweitern Sie im DSL-Explorer die Option XML-Serialisierungsverhalten und anschließend Klassendaten.
Führen Sie für jede Klasse, für die Sie ModelBus-Verweise erstellen möchten, folgende Schritte aus:

Klicken Sie auf den Klassenknoten, und stellen Sie im Fenster Eigenschaften sicher, dass für ID serialisieren der Wert true festgelegt ist.

Wenn Sie statt GUIDs Elementnamen für die Identifikation von Elementen verwenden möchten, können Sie alternativ Teile der generierten Adapter überschreiben. Überschreiben Sie in der Adapterklasse die folgende Methoden:

Überschreiben Sie GetElementId, damit die gewünschte ID zurückgegeben wird. Diese Methode wird aufgerufen, wenn Verweise erstellt werden.
Überschreiben Sie ResolveElementReference, um das richtige Element in einem ModelBus-Verweis zu finden.

Zugreifen auf eine DSL von einer anderen DSL

Sie können ModelBus-Verweise in einer Domäneneigenschaft in einer DSL speichern und dann benutzerdefinierten Code schreiben, der sie nutzt. Sie können es auch Benutzer*innen ermöglichen, einen ModelBus-Verweis durch Auswählen einer Modelldatei und eines darin enthaltenen Elements zu erstellen.

Damit eine DSL Verweise auf eine andere DSL verwenden kann, müssen Sie sie zu einem Consumer von ModelBus-Verweisen machen.

So aktivieren Sie eine DSL als Consumer von Verweisen auf eine verfügbar gemachte DSL

Klicken Sie im Diagramm DSL-Definition mit der rechten Maustaste auf den Hauptteil des Diagramms, und klicken Sie dann auf ModelBus aktivieren.
Wählen Sie im Dialogfeld die Option Ich möchte dieses Modell als Consumer für ModelBus-Verweise aktivieren aus.
Fügen Sie im Dsl-Projekt der Consumer-DSL den Projektverweisen die folgenden Assemblys hinzu. Diese Assemblys (DLL-Dateien) befinden sich im Verzeichnis ModelBusAdapter\bin\* der verfügbar gemachten DSL.
- Die verfügbar gemachte DSL-Assembly, z. B. Fabrikam.FamilyTree.Dsl.dll
- Die verfügbar gemachte Assembly des ModelBus-Adapters, z. B. Fabrikam.FamilyTree.ModelBusAdapter.dll
Fügen Sie die folgenden .NET-Assemblys den Projektverweisen des Consumer-DSL-Projekts hinzu.
- Microsoft.VisualStudio.Modeling.Sdk.Integration.dll
- Microsoft.VisualStudio.Modeling.Sdk.Integration.Shell.dll

So speichern Sie einen ModelBus-Verweis in einer Domäneneigenschaft

Fügen Sie in der DSL-Definition der Consumer-DSL einer Domänenklasse eine Domäneneigenschaft hinzu, und legen Sie ihren Namen fest.
Legen Sie im Fenster Eigenschaften bei ausgewählter Domäneneigenschaft den Typ auf ModelBusReference fest.

In dieser Phase können Sie mit Programmcode den Eigenschaftswert festlegen. Der Wert ist im Fenster Eigenschaften schreibgeschützt.

Sie können es den Benutzer*innen ermöglichen, die Eigenschaft mit einem speziellen ModelBus-Verweis-Editor festzulegen. Für diesen Editor (auch Auswahl genannt) gibt es zwei Versionen: Mit der einen können Benutzer*innenn eine Modelldatei auswählen, mit der anderen eine Modelldatei und ein Element innerhalb des Modells.

So ermöglichen Sie es Benutzer*innen, einen ModelBus-Verweis in einer Domäneneigenschaft festzulegen

Klicken Sie mit der rechten Maustaste auf die Domäneneigenschaft, und klicken Sie dann auf Spezifische Eigenschaften für ModelBus-Verweise bearbeiten. Das Dialogfeld ModelBus-Auswahl wird geöffnet.
Wählen Sie die entsprechende Art von ModelBus-Verweis aus: ein Modell oder ein Element in einem Modell.
Geben Sie im Dateidialogfeld für die Filterzeichenfolge eine Zeichenfolge wie Family Tree files |*.ftree ein. Ersetzen Sie die Dateierweiterung der verfügbar gemachten DSL.
Wenn Sie auf ein Element in einem Modell verweisen möchten, können Sie eine Liste der Typen hinzufügen, aus denen die Benutzer*innen auswählen können, z. B. Company.FamilyTree.Person.
Klicken Sie auf OK und anschließend in der Symbolleiste des Projektmappen-Explorers auf Alle Vorlagen transformieren.

Warnung

Wenn Sie kein gültiges Modell bzw. keine gültige Entität ausgewählt haben, besitzt die Schaltfläche OK keine Funktion, auch wenn sie aktiv aussieht.
Wenn Sie eine Liste von Zieltypen wie etwa Company.FamilyTree.Person angegeben haben, müssen Sie einen Assemblyverweis auf Ihr DSL-Projekt hinzufügen. Verweisen Sie hierzu auf die DLL der Ziel-DSL, z. B. Company.FamilyTree.Dsl.dll.

So testen Sie einen ModelBus-Verweis

Erstellen Sie die verfügbar gemachte DSL und die Consumer-DSL.
Drücken Sie F5 oder STRG+F5, um eine der DSLs im experimentellen Modus auszuführen.
Fügen Sie im Debuggingprojekt in der experimentellen Instanz von Visual Studio Dateien hinzu, die Instanzen der DSLs sind.

Hinweis

Visual Studio ModelBus kann nur Verweise auf Modelle auflösen, die sich in derselben Visual Studio-Projektmappe befinden. Sie können beispielsweise keinen Verweis auf eine Modelldatei in einem anderen Teil Ihres Dateisystems erstellen.
Erstellen Sie einige Elemente und Links in der Instanz der verfügbar gemachten DSL, und speichern Sie sie.
Öffnen Sie eine Instanz der Consumer-DSL, und wählen Sie ein Modellelement aus, dass eine Eigenschaft für einen Modellbusverweis enthält.
Doppelklicken Sie im Fenster Eigenschaften auf die Eigenschaft für einen ModelBus-Verweis. Das Auswahldialogfeld wird geöffnet.
Klicken Sie auf Durchsuchen, und wählen Sie die Instanz der verfügbar gemachten DSL aus.

Wenn Sie einen elementspezifischen ModelBus-Verweis angegeben haben, können Sie über die Auswahl auch ein Element im Modell auswählen.

Erstellen von Verweisen im Programmcode

Wenn Sie einen Verweis auf ein Modell oder ein Element in einem Modell speichern möchten, erstellen Sie einen ModelBusReference-Verweis. Es gibt zwei Arten von ModelBusReference: Modellverweise und Elementverweise.

Für die Erstellung eines Modellverweises benötigen Sie den Adapter-Manager der DSL, von der das Modell eine Instanz ist, sowie den Dateinamen oder das Visual Studio-Projektelement des Modells.

Zum Erstellen eines Elementverweises benötigen Sie einen Adapter für die Modelldatei und ein Element, auf das Sie verweisen möchten.

Hinweis

Mit Visual Studio ModelBus können Sie nur Verweise auf Elemente erstellen, die sich in derselben Visual Studio-Projektmappe befinden.

Importieren der verfügbar gemachten DSL-Assemblys

Fügen Sie im Consumerprojekt Projektverweise auf die DSL und die ModelBusAdapter-Assemblys der verfügbar gemachten DSL hinzu.

Angenommen, Sie möchten ModelBus-Verweise in Elementen einer MusicLibrary-DSL speichern. Die ModelBus-Verweise verweisen auf Elemente der FamilyTree-DSL. Fügen Sie im Dsl-Projekt der MusicLibrary-Projektmappe im Knoten „Verweise“ Verweise auf die folgenden Assemblys hinzu:

Fabrikam.FamilyTree.Dsl.dll: Die verfügbar gemachte DSL.
Fabrikam.FamilyTree.ModelBusAdapters.dll: Der ModelBus-Adapter der verfügbar gemachten DSL.
Microsoft.VisualStudio.Modeling.Sdk.Integration
Microsoft.VisualStudio.Modeling.Sdk.Integration.Shell:

Diese Assemblys befinden sich im ModelBusAdapters-Projekt der verfügbar gemachten DSL unter „*bin\**“.

In der Regel müssen Sie die folgenden Namespaces in die Codedatei importieren, in der Sie Verweise erstellen:

// 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;
...

So erstellen Sie einen Verweis auf ein Modell

Zum Erstellen eines Modellverweises greifen Sie auf den AdapterManager der verfügbar gemachten DSL zu und erstellen damit einen Verweis auf das Modell. Sie können einen Dateipfad oder ein EnvDTE.ProjectItem angeben.

Vom AdapterManager können Sie einen Adapter abrufen, der Zugriff auf einzelne Elemente im Modell bietet.

Hinweis

Sie müssen einen Adapter löschen, wenn Sie damit fertig sind. Sie erreichen dies am einfachsten mit einer using-Anweisung. Dies wird anhand des folgenden Beispiels veranschaulicht.

// 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

Für eine spätere Nutzung können Sie modelReference in einer Domäneneigenschaft speichern, die ModelBusReference mit einem externen Typ aufweist:

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

Damit Benutzer*innen diese Domäneneigenschaft bearbeiten können, verwenden Sie ModelReferenceEditor als Parameter im Attribut Editor. Weitere Informationen zum Zulassen der Bearbeitung eines Verweises durch Benutzer*innen finden Sie im Abschnitt Zugreifen auf eine DSL von einer anderen DSL.

So erstellen Sie einen Verweis auf ein Element

Der Adapter, den Sie für das Modell erstellt haben, kann zum Erstellen und Auflösen von Verweisen verwendet werden.

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

Für eine spätere Nutzung können Sie elementReference in einer Domäneneigenschaft speichern, die ModelBusReference mit einem externen Typ aufweist. Damit Benutzer*innen ihn bearbeiten können, verwenden Sie ModelElementReferenceEditor als Parameter im Attribut Editor. Weitere Informationen zum Zulassen der Bearbeitung eines Verweises durch Benutzer*innen finden Sie im Abschnitt Zugreifen auf eine DSL von einer anderen DSL.

Auflösen von Verweisen

Wenn Sie über einen ModelBusReference (MBR) verfügen, können Sie das Modell oder das Modellelement abrufen, auf das verwiesen wird. Wenn das Element im Diagramm oder einer anderen Ansicht vorhanden ist, können Sie die Ansicht öffnen und das Element auswählen.

Sie können einen Adapter mit einem MBR erstellen. Vom Adapter können Sie den Stamm des Modells abrufen. Darüber hinaus können Sie MBRs auflösen, die auf bestimmte Elemente im Modell verweisen.

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.

So lösen Sie ModelBus-Verweise in einer Textvorlage auf

Die DSL, auf die Sie zugreifen möchten, muss einen ModelBus-Adapter aufweisen, der für Zugriff durch Textvorlagen konfiguriert ist. Weitere Informationen finden Sie unter Bereitstellen von Zugriff auf eine DSL.

Normalerweise greifen Sie auf eine Ziel-DSL mit einem ModelBus-Verweis zu, der in einer Quell-DSL gespeichert ist. Ihre Vorlage enthält deshalb die Direktive der Quell-DSL sowie Code zur MBR-Auflösung. Weitere Informationen zu Textvorlagen finden Sie unter Generieren von Code für eine domänenspezifische Sprache.

<#@ 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 #>]]
<#
  }
#>

Weitere Informationen sowie eine exemplarische Vorgehensweise finden Sie unter Verwenden von Visual Studio ModelBus in einer Textvorlage.

Serialisieren eines ModelBus-Verweises

Wenn Sie einen ModelBusReference (MBR) als Zeichenfolge speichern möchten, können Sie ihn serialisieren:

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

Ein auf diese Weise serialisierter ModelBus-Verweis ist kontextunabhängig. Wenn Sie den einfachen dateibasierten ModelBus-Adapter verwenden, enthält der ModelBus-Verweis einen absoluten Dateipfad. Diese Serialisierung ist ausreichend, wenn die Modelldateien der Instanz nicht verschoben werden. Üblicherweise sind die Modelldateien jedoch Elemente in einem Visual Studio-Projekt. Daher werden Ihre Benutzer*innen erwarten, dass sie das gesamte Projekt in andere Teile des Dateisystems verschieben können. Sie werden außerdem erwarten, dass sie für das Projekt Quellcodeverwaltung nutzen und es auf verschiedenen Computern öffnen können. Pfadnamen sollten daher relativ zum Speicherort des Projekts serialisiert werden, das die Dateien enthält.

Serialisieren relativ zum angegebenen Dateipfad

Ein ModelBusReference enthält einen ReferenceContext, ein Wörterbuch, in dem Sie Informationen wie den Dateipfad speichern können, relativ zu dem die Serialisierung erfolgen soll.

So serialisieren Sie relativ zu einem Pfad

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

So rufen Sie den Verweis aus der Zeichenfolge ab

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

Von anderen Adaptern erstellte ModelBus-Verweise

Die folgenden Informationen sind nützlich, wenn Sie einen eigenen Adapter erstellen möchten.

Ein ModelBusReference (MBR) besteht aus zwei Teilen: dem MBR-Header, der vom Modellbus deserialisiert wird, und einer adapterspezifischen Angabe, die vom spezifischen Adapter-Manager verarbeitet wird. Auf diese Weise können Sie ein eigenes Serialisierungsformat für Adapter angeben. Sie könnten beispielsweise auf eine Datenbank statt auf eine Datei verweisen. Sie könnten auch weitere Informationen im Adapterverweis speichern. Ihr eigener Adapter könnte weitere Informationen zum ReferenceContext hinzufügen.

Wenn Sie einen MBR deserialisieren, müssen Sie einen ReferenceContext angeben, der dann im MBR-Objekt gespeichert wird. Wenn Sie einen MBR serialisieren, wird der gespeicherte ReferenceContext vom Adapter zur Generierung der Zeichenfolge verwendet. Die deserialisierte Zeichenfolge enthält nicht die gesamten Informationen im Verweiskontext. Beim einfachen dateibasierten Adapter enthält der Verweiskontext einen Stammdateipfad. Dieser Pfad wird nicht in der serialisierten Zeichenfolge des ModelBus-Verweises gespeichert.

Der MBR wird in zwei Stufen deserialisiert:

ModelBusReferencePropertySerializer ist ein Standardserialisierungsprogramm, das den Header des ModelBus-Verweises verarbeitet. Es verwendet die standardmäßige DSL-Eigenschaftensammlung SerializationContext, die mit dem Schlüssel ReferenceContext im ModelBusReferencePropertySerializer.ModelBusLoadContextKey gespeichert wird. Insbesondere der SerializationContext sollte eine Instanz von ModelBus enthalten.
Ihr ModelBus-Adapter verarbeitet den adapterspezifischen Teil des MBR. Er kann weitere Informationen verwenden, die im ReferenceContext des MBR gespeichert sind. Der einfache dateibasierte Adapter behält die Stammdateipfade mit den Schlüsseln FilePathLoadContextKey und FilePathSaveContextKey bei.

Ein Adapterverweis in einer Modelldatei wird nur deserialisiert, wenn er verwendet wird.

Erstellen eines Modells

Erstellen, Öffnen und Bearbeiten eines Modells

Das folgende Fragment stammt aus dem Beispiel des Zustandsautomaten auf der VMSDK-Website. Es veranschaulicht die Verwendung von ModelBusReferences zum Erstellen und Öffnen eines Modells und zum Abrufen des mit dem Modell verbundenen Diagramms.

In diesem Beispiel lautet der Name der Ziel-DSL "StateMachine". Davon werden verschiedene Namen abgeleitet, beispielsweise der Name der Modellklasse und der ModelBusAdapter-Name.

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();
    }
}

Überprüfen von Verweisen

Mit BrokenReferenceDetector werden alle Domäneneigenschaften in einem Speicher getestet, der ModelBusReferences enthalten kann. Er ruft die angegebene Aktion auf, wenn eine Aktion gefunden wird. Dieser Test ist für Überprüfungsmethoden nützlich. Mit der folgenden Überprüfungsmethode wird der Speicher bei dem Versuch getestet, das Modell zu speichern, dabei werden beschädigte Verweise im Fehlerfenster angegeben:

[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";

Von der ModelBus-Erweiterung ausgeführte Aktionen

Die folgenden Informationen können nützlich sein, wenn Sie ModelBus intensiv nutzen.

Mit der ModelBus-Erweiterung werden die folgenden Änderungen an Ihrer DSL-Projektmappe vorgenommen.

Klicken Sie mit der rechten Maustaste auf das Diagramm „DSL-Definition“. Klicken Sie auf ModelBus aktivieren und dann auf Diese DSL als ModelBus-Consumer aktivieren:

Fügen Sie im DSL-Projekt der Datei Microsoft.VisualStudio.Modeling.Sdk.Integration.dll einen Verweis hinzu.
In der DSL-Definition wird ein Verweis auf einen externen Typ hinzugefügt: Microsoft.VisualStudio.Modeling.Integration.ModelBusReference.

Der Verweis wird im DSL-Explorer unter Domänentypen angezeigt. Klicken Sie auf den Stammknoten, um Verweise auf externe Typen hinzuzufügen.
Die folgende neue Vorlagendatei wird hinzugefügt: Dsl\GeneratedCode\ModelBusReferencesSerialization.tt.

Legen Sie den Typ einer Domäneneigenschaft auf „ModelBusReference“ fest. Klicken Sie dann mit der rechten Maustaste auf die Eigenschaft, und klicken Sie auf Spezifische Eigenschaften für ModelBus-Verweise aktivieren:

Der Domäneneigenschaft werden mehrere CLR-Attribute hinzugefügt. Sie werden im Fenster Eigenschaften im Feld Benutzerdefinierte Attribute angezeigt. In Dsl\GeneratedCode\DomainClasses.cs können Sie die Attribute der Eigenschaftendeklaration anzeigen:

[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")]

Klicken Sie mit der rechten Maustaste auf das Diagramm DSL-Definition. Klicken Sie dann auf ModelBus aktivieren und auf Diese DSL für ModelBus verfügbar machen:

Der Projektmappe wird ein neues ModelBusAdapter-Projekt hinzugefügt.
Dem ModelBusAdapter-Projekt wird ein Verweis auf DslPackage hinzugefügt. ModelBusAdapter weist einen Verweis auf das Dsl-Projekt auf.
In DslPackage\source.extention.tt wird |ModelBusAdapter| als MEF-Komponente hinzugefügt.

Share via

Integrieren von Modellen mit Visual Studio ModelBus

Bereitstellen von Zugriff auf eine DSL

So machen Sie eine DSL-Definition für ModelBus verfügbar

Sicherstellen, dass auf Elemente verwiesen werden kann

Zugreifen auf eine DSL von einer anderen DSL

So aktivieren Sie eine DSL als Consumer von Verweisen auf eine verfügbar gemachte DSL

So speichern Sie einen ModelBus-Verweis in einer Domäneneigenschaft

So ermöglichen Sie es Benutzer*innen, einen ModelBus-Verweis in einer Domäneneigenschaft festzulegen

So testen Sie einen ModelBus-Verweis

Erstellen von Verweisen im Programmcode

Importieren der verfügbar gemachten DSL-Assemblys

So erstellen Sie einen Verweis auf ein Modell

So erstellen Sie einen Verweis auf ein Element

Auflösen von Verweisen

So lösen Sie ModelBus-Verweise in einer Textvorlage auf

Serialisieren eines ModelBus-Verweises

Serialisieren relativ zum angegebenen Dateipfad

Von anderen Adaptern erstellte ModelBus-Verweise

Erstellen eines Modells

Erstellen, Öffnen und Bearbeiten eines Modells

Überprüfen von Verweisen

Von der ModelBus-Erweiterung ausgeführte Aktionen

Feedback

Feedback

Zusätzliche Ressourcen

Share via

Integrieren von Modellen mit Visual Studio ModelBus

Bereitstellen von Zugriff auf eine DSL

So machen Sie eine DSL-Definition für ModelBus verfügbar

Sicherstellen, dass auf Elemente verwiesen werden kann

Zugreifen auf eine DSL von einer anderen DSL

So aktivieren Sie eine DSL als Consumer von Verweisen auf eine verfügbar gemachte DSL

So speichern Sie einen ModelBus-Verweis in einer Domäneneigenschaft

So ermöglichen Sie es Benutzer*innen, einen ModelBus-Verweis in einer Domäneneigenschaft festzulegen

So testen Sie einen ModelBus-Verweis

Erstellen von Verweisen im Programmcode

Importieren der verfügbar gemachten DSL-Assemblys

So erstellen Sie einen Verweis auf ein Modell

So erstellen Sie einen Verweis auf ein Element

Auflösen von Verweisen

So lösen Sie ModelBus-Verweise in einer Textvorlage auf

Serialisieren eines ModelBus-Verweises

Serialisieren relativ zum angegebenen Dateipfad

Von anderen Adaptern erstellte ModelBus-Verweise

Erstellen eines Modells

Erstellen, Öffnen und Bearbeiten eines Modells

Überprüfen von Verweisen

Von der ModelBus-Erweiterung ausgeführte Aktionen

Zugehöriger Inhalt

Feedback

Feedback

Zusätzliche Ressourcen