Integrazione di modelli tramite ModelBus di Visual Studio

Visual Studio ModelBus fornisce un metodo per creare collegamenti tra i modelli e da altri strumenti nei modelli.Ad esempio, è possibile collegare i (DSL) modelli di linguaggio specifico di dominio e i modelli UML.È possibile creare un insieme integrato di DSLs.

ModelBus consente di creare un riferimento univoco a un modello o un elemento specifico in un modello.Questo può essere un riferimento esterno archiviato il modello, ad esempio, in un elemento in un altro modello.Quando, in un'occasione successiva, uno strumento desidera ottenere l'accesso all'elemento, l'infrastruttura di template bus) carica il modello appropriato e restituirà l'elemento.Se lo si desidera, è possibile visualizzare il modello all'utente.Se il file non è possibile accedervi nella relativa posizione precedente, ModelBus chiede all'utente di trovarlo.Se l'utente trova il file, ModelBus correggerà tutti i riferimenti a tale file.

[!NOTA]

In corrente Visual Studio l'implementazione ModelBus, i modelli collegati deve essere gli stessi elementi Visual Studio soluzione.

Per ulteriori informazioni e il codice di esempio, vedere:

• Procedura: aggiungere un gestore di trascinamento della selezione

• Visual Studio Sito Web dell'SDK di visualizzazione e modellazione (VMSDK)

Fornendo accesso a un modello DSL

Prima di poter creare i riferimenti ModelBus a un modello o ai relativi elementi, è necessario definire un ModelBusAdapter per il linguaggio DSL.Il modo più semplice per ottenere questo risultato consiste di utilizzare Visual Studio Estensione di bus di modello, che aggiunge i controlli nella finestra di progettazione DSL.

Per esporre una definizione di modello DSL per modellare bus)

1. Scaricare e installare l'estensione di bus del modello di Visual Studio, a meno che non sia già installato.Per ulteriori informazioni, vedere L'sdk di visualizzazione e modellazione.

2. Aprire il file di definizione DSL.Fare clic con il pulsante destro del mouse sull'area di progettazione e scegliere abilitare Modelbus.

3. Nella finestra di dialogo selezionare, Si desidera esporre il modello DSL a ModelBus.È possibile scegliere entrambe le opzioni per ottenere questo modello DSL sia per esporre i relativi modelli che per utilizzare i riferimenti all'altro DSLs.

4. Scegliere OK.Un nuovo progetto “ModelBusAdapter„ aggiunto alla soluzione DSL.

5. Se si desidera accedere al modello DSL da un modello di testo, è necessario modificare AdapterManager.tt nel nuovo progetto.Saltare questo passaggio se si desidera accedere al modello DSL da altro codice come i comandi e gestori eventi.Per ulteriori informazioni, vedere Utilizzo di ModelBus di Visual Studio in un modello di testo.

   1. modificare la classe di base di AdapterManagerBase a VsTextTemplatingModelingAdapterManager.

   2. Alla fine del file, inserire questo attributo aggiuntivo davanti alla classe AdapterManager:

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

   3. Nei riferimenti del progetto ModelBusAdapter, aggiungere Microsoft.VisualStudio.TextTemplating.Modeling.11.0.

   Se si desidera accedere al modello DSL sia dai modelli di testo che da altro codice, sono necessari due adattatori, uno stato modificato e uno invariato.

6. Fare clic su Trasformazione di tutti i modelli.

7. Ricompilare la soluzione.

Ora è possibile che ModelBus apra le istanze di questo modello DSL.

la cartella ModelBusAdapters\bin\* contiene gli assembly compilati da Dsl progetto e ModelBusAdapters progetto.Per fare riferimento a questo modello DSL da un altro modello DSL, è necessario includere questi assembly.

Assicurarsi che gli elementi possano farvi riferimento

Visual Studio Gli adattatori ModelBus utilizzano il GUID di un elemento per identificarla, per impostazione predefinita.Questi identificatori devono quindi essere mantenuti nel file di modello.

Per assicurarsi che gli ID viene salvato in modo permanente

1. aprire DslDefinition.dsl.

2. Nel modello DSL Esplora Soluzioni, espandere comportamento di serializzazione XML, quindi Dati della classe.

3. Per ogni classe a cui si desidera creare model bus di modello fa riferimento:

   Fare clic sul nodo della classe e nella Finestra Proprietà, assicurarsi che Serializzare ID. è impostato su true.

In alternativa, se si desidera utilizzare i nomi degli elementi per identificare gli elementi anziché i guids, è possibile eseguire l'override delle parti degli adattatori generati.Eseguire l'override dei metodi nella classe di adattatori:

• override GetElementId per restituire identificatore che si desidera utilizzare.Questo metodo viene chiamato quando si creano i riferimenti.

• override ResolveElementReference per posizionare l'elemento corretto da un riferimento di template bus).

Accedere a un modello DSL da un altro modello DSL

È possibile archiviare i riferimenti di template bus) in una proprietà di dominio in un modello DSL e è possibile scrivere codice personalizzato che li utilizza.È inoltre possibile che l'utente creare un riferimento di template bus selezionando un file di modello e un elemento.

Per consentire a un modello DSL per utilizzare i riferimenti a un altro modello DSL, è innanzitutto necessario renderlo un oggetto utente i riferimenti di template bus).

Per consentire a un modello DSL per utilizzare i riferimenti a un modello DSL esposto

1. Nel diagramma della definizione di modello DSL, fare clic con il pulsante destro del mouse sulla parte principale del diagramma e scegliere abilitare Modelbus.

2. Nella finestra di dialogo, selezionare Si desidera consentire a questo modello per utilizzare i riferimenti di template bus).

3. Nel progetto di Dsl di IL consumer, aggiungere gli assembly seguenti ai riferimenti del progetto.Questi assembly (file dll) nel ModelBusAdapter \bin\* directory of the exposed DSL.

   • L'assembly esposto DSL, ad esempio Fabrikam.FamilyTree.Dsl.dll

   • L'assembly di modello esposto del bus), ad esempio Fabrikam.FamilyTree.ModelBusAdapter.dll

4. Aggiungere i seguenti assembly.NET ai riferimenti al progetto consumer DSL.

   1. Microsoft.VisualStudio.Modeling.Sdk.Integration.11.0.dll

   2. Microsoft.VisualStudio.Modeling.Sdk.Integration.Shell.11.0.dll

Per memorizzare un riferimento di template bus) in una proprietà del dominio

1. Nella definizione di modello DSL di IL consumer, aggiungere una proprietà di dominio a una classe di dominio e impostarne il nome.

2. Nella Finestra Proprietà, con la proprietà del dominio selezionata, impostare tipo in ModelBusReference.

In questa fase, il codice programma possibile impostare il valore della proprietà, ma è di sola lettura nella Finestra Proprietà.

È possibile consentire agli utenti impostare la proprietà con un editor di riferimento specializzato ModelBus.Esistono due versioni di questo editor o selezione: uno consente agli utenti scelgano un file di modello e l'altro consente agli utenti scelgano un file di modello e un elemento all'interno del modello.

Per consentire all'utente di impostare un riferimento di template bus) in una proprietà del dominio

1. Fare clic con il pulsante destro del mouse sulla proprietà del dominio quindi fare clic su modificare le proprietà specifiche di ModelBusReference.Verrà visualizzata una finestra di dialogo.Si tratta Selezione di template bus).

2. Selezionare l'oggetto appropriato tipo di ModelBusReference: a un modello o un elemento in un modello.

3. Nella stringa di filtro della finestra di dialogo dei file, immettere una stringa come Family Tree files |*.ftree.Subsitute l'estensione del file modello DSL esposto.

4. Se si intende fare riferimento a un elemento in un modello, è possibile aggiungere un elenco di tipi che l'utente può selezionare, ad esempio Company.FamilyTree.Person.

5. Fare clic su Scegliere OKquindi scegliere Trasformazione di tutti i modelli nella barra degli strumenti di Esplora soluzioni.

   Attenzione
   Se non è selezionato un modello o un oggetto valido, il pulsante OK non avrà alcun effetto, anche se può essere attivato.

6. Se è stato specificato un elenco di tipi di destinazione come Company.FamilyTree.Person, è necessario aggiungere un riferimento al progetto di modello DSL, facendo riferimento alla DLL del database di destinazione di DSL, ad esempio Company.FamilyTree.Dsl.dll

Per testare un riferimento di template bus)

1. Compilare sia il DSLs esposto da consumer.

2. Eseguire uno di DSLs in modalità sperimentale premendo F5 o CTRL+F5.

3. Nel progetto di debug nell'istanza sperimentale di Visual Studio, aggiungere i file che sono istanze di ciascun modello DSL.

   [!NOTA]

   Visual Studio ModelBus possibile risolvere solo i riferimenti ai modelli che sono elementi nello stesso oggetto Visual Studio soluzione.Ad esempio, non è possibile creare un riferimento a un file di modello in un'altra parte del file system.

4. Creare alcuni elementi e collegamenti nell'istanza del linguaggio DSL esposto e salvarlo.

5. Aprire un'istanza del modello DSL consumer e selezionare un elemento del modello che dispone di una proprietà del riferimento bus di modello.

6. Nella Finestra Proprietà, fare doppio clic sulla proprietà del riferimento bus di modello.La finestra di dialogo di selezione è aperto.

7. Fare clic su Navigazione e selezionare l'istanza del linguaggio DSL esposto.

   La selezione viene inoltre consentono di scegliere un elemento nel modello, se è stato specificato il tipo i di riferimento del modello di bus).

Creare i riferimenti nel codice programma

Quando si desidera archiviare un riferimento a un modello o un elemento in un modello, creare un oggetto ModelBusReference.Esistono due tipi di ModelBusReference: riferimenti del modello e riferimenti dell'elemento.

Per creare un riferimento del modello, è necessario disporre del AdapterManager del linguaggio DSL del quale il modello è un'istanza e il nome file o Visual Studio elemento di progetto di modello.

Per creare un riferimento dell'elemento, è necessario un adattatore per il file di modello e dell'elemento che si desidera fare riferimento a.

[!NOTA]

con Visual Studio ModelBus, è possibile creare riferimenti solo agli elementi nello stesso oggetto Visual Studio soluzione.

Importare gli assembly esposti DSL

Nel progetto consumer, aggiungere i riferimenti al progetto al modello DSL e gli assembly di ModelBusAdapter del linguaggio DSL esposto.

Si supponga, ad esempio per archiviare i riferimenti ModelBus negli elementi di un MusicLibrary DSL.I riferimenti ModelBus è segnaleranno agli elementi di FamilyTree DSL.in Dsl il progetto della soluzione di MusicLibrary, nel nodo riferimenti, aggiungere i riferimenti agli assembly seguenti:

• Fabrikam.FamilyTree.Dsl.dll - il modello DSL esposto.

• Fabrikam.FamilyTree.ModelBusAdapters.dll - l'adattatore ModelBus del linguaggio DSL esposto.

• Microsoft.VisualStudio.Modeling.Sdk.Integration.11.0

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

Questi assembly sono disponibili in ModelBusAdapters progetto di modello DSL esposto, in bin\*.

Nel file di codice in cui verranno creati i riferimenti, in genere è necessario importare gli spazi dei nomi:

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

Per creare un riferimento a un modello

Per creare un riferimento del modello, è possibile accedere al AdapterManager per il linguaggio DSL esposto e utilizzarlo per creare un riferimento al modello.È possibile specificare un percorso di file, o un oggetto EnvDTE.ProjectItem.

Dal AdapterManager, è possibile ottenere un adattatore, che fornisce l'accesso ai singoli elementi del modello.

[!NOTA]

È necessario eliminare un adattatore dopo avere completato con.Il modo più pratico per ottenere questo risultato consiste con un oggetto using istruzione.Questa condizione è illustrata nell'esempio che segue.

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

Se si desidera utilizzare modelReference successivamente, è possibile archiviarlo in una proprietà di dominio con il tipo esterno ModelBusReference:

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

Per consentire agli utenti di modificare la proprietà del dominio, utilizzare ModelReferenceEditor come parametro nell'attributo dell'editor.Per ulteriori informazioni, vedere Consentire all'utente di modificare un riferimento.

Per creare un riferimento a un elemento

L'adattatore creata per il modello può essere utilizzato per creare e risolvere i riferimenti.

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

Se si desidera utilizzare elementReference successivamente, è possibile archiviarlo in una proprietà di dominio con il tipo esterno ModelBusReference.Per consentire agli utenti di modificare, utilizzare ModelElementReferenceEditor come parametro nell'attributo dell'editor.Per ulteriori informazioni, vedere Consentire all'utente di modificare un riferimento.

risolvere i riferimenti

Se si dispone di un oggetto ModelBusReference (MBR) è possibile ottenere il modello o l'elemento del modello a cui fa riferimento.Se l'elemento è verificato in un diagramma o un'altra visualizzazione, è possibile aprire la visualizzazione e selezionare l'elemento.

È possibile creare un adattatore da un MBR.Dall'adattatore, è possibile ottenere la radice del modello.È anche possibile risolvere i MBR che fanno riferimento a elementi specifici all'interno del modello.

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.

Per risolvere i riferimenti a ModelBus nel modello di testo

1. Il modello DSL cui si desidera accedere necessario disporre di un adattatore ModelBus configurato per l'accesso dai modelli di testo.Per ulteriori informazioni, vedere To provide access to a DSL.

2. In genere, si accederà un database di destinazione DSL utilizzando un riferimento di template bus (MBR) memorizzato in un database di origine DSL.Il modello includerà la direttiva del database di origine DSL, più il codice per risolvere il MBR.Per ulteriori informazioni sui modelli di testo, vedere Generazione di codice da un linguaggio specifico di dominio.

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

Per ulteriori informazioni e una procedura dettagliata, vedere Utilizzo di ModelBus di Visual Studio in un modello di testo

serializzare un ModelBusReference

Se si desidera archiviare un oggetto ModelBusReference (MBR) sotto forma di stringa, è possibile serializzarlo:

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

Un MBR che viene serializzato in questo modo è indipendente dal contesto.Se si utilizza l'adattatore semplice di bus del modello basato su file, il MBR contiene un percorso di file assoluto.Ciò è sufficiente se i file di modello di istanza non verranno spostati mai.Tuttavia, i file di modello in genere verranno elementi in un controllo Visual Studio progetto.Gli utenti penseranno per poter spostare l'intero progetto alle diverse parti del file system.Inoltre penseranno per poter archiviare il progetto nel controllo del codice sorgente e aprirlo su computer diversi.I nomi dei percorsi devono pertanto essere serializzati relativi alla posizione del progetto che contiene i file.

Serializzazione relativo a un percorso file specificato

In ModelBusReference contiene un oggetto ReferenceContext, che è un dizionario in cui è possibile memorizzare le informazioni quali il relativo percorso di file che deve essere serializzata.

Per serializzare relativo a un percorso:

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

Per recuperare il riferimento dalla stringa:

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

ModelBusReferences ha creato da altri adattatori

Le informazioni seguenti sono utili se si desidera creare diventi proprietaria l'adattatore.

In ModelBusReference (MBR) è costituita da due parti: l'intestazione di MBR, che deve essere deserializzata in bus di modello e uno adattatore-specifico che viene gestito dall'amministratore specifico dell'adattatore.Ciò consente di fornire diventi proprietaria il formato di serializzazione dell'adattatore.Ad esempio, è possibile fare riferimento a un database anziché un file, oppure è possibile archiviare le informazioni aggiuntive nel riferimento dell'adattatore.Possedere l'adattatore può inserire le informazioni aggiuntive in ReferenceContext.

Quando deserializzate un MBR, è necessario fornire un ReferenceContext, che viene quindi archiviato nell'oggetto di MBR.Quando serializzate un MBR, il ReferenceContext archiviato è utilizzato dall'adattatore per generare la stringa.La stringa deserializzata non contiene tutte le informazioni nel ReferenceContext.Ad esempio, nell'adattatore basato su file semplice, il ReferenceContext contiene un percorso di file radice, che non è archiviato nella stringa serializzata di MBR.

Il MBR viene deserializzato in due fasi:

• ModelBusReferencePropertySerializer è il serializzatore standard che si occupa dell'intestazione di MBR.utilizza lo standard DSL SerializationContext contenitore di proprietà, archiviato in ReferenceContext utilizzando la chiave ModelBusReferencePropertySerializer.ModelBusLoadContextKey.in particolare, SerializationContext deve contenere un'istanza di ModelBus.

• L'adattatore ModelBus si occupa della parte adattatore-specifica di MBR.Può utilizzare le informazioni aggiuntive archiviate nel ReferenceContext di MBR.L'adattatore basato su file semplice mantiene i percorsi di file radice utilizzando le chiavi FilePathLoadContextKeye FilePathSaveContextKey.

  Un riferimento dell'adattatore in un file di modello viene deserializzato solo quando viene utilizzato.

Per creare un modello

Creazione, apertura e modifica di un modello

Nel frammento viene preso dalla macchina a stati sul sito Web dell'archivio VMSDK.Viene illustrato l'utilizzo di ModelBusReferences creare e aprire un modello e ottenere il diagramma associato al modello.

In questo esempio, il nome del database di destinazione DSL è StateMachine.Diversi nomi sono derivati da, ad esempio il nome della classe di modello e il nome del 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();
    }
}

convalidare i riferimenti

Il BrokenReferenceDetector verifica tutte le proprietà di dominio in un archivio che possibile utilizzare ModelBusReferences.Si richiama l'azione che fornisce dove qualsiasi azione viene trovata.Questo risulta particolarmente utile per i metodi di convalida.Il seguente metodo di convalida sia l'archivio in un tentativo di salvare il modello e segnala riferimenti conseguenti nella finestra di errore:

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

Azioni eseguite dall'estensione ModelBus

Le informazioni seguenti non sono essenziali, ma potrebbero risultare utili nel caso di utilizzo esteso ModelBus.

L'estensione ModelBus apportare le seguenti modifiche nella soluzione DSL.

Quando si fa clic con il pulsante destro del mouse sul diagramma della definizione di modello DSL, fare clic su abilitare Modelbusquindi selezionare Consentire a questo modello DSL per utilizzare il ModelBus:

• Nel progetto di modello DSL, viene aggiunto un riferimento a Microsoft.VisualStudio.Modeling.Sdk.Integration.11.0.dll

• Nella definizione di modello DSL, un riferimento esterno del tipo viene aggiunto: Microsoft.VisualStudio.Modeling.Integration.ModelBusReference.

  È possibile visualizzare il riferimento in DSL Esplora Risorsein, Tipi di dominio.Per aggiungere riferimenti esterni del tipo manualmente, fare clic con il pulsante destro del mouse sul nodo radice.

• Un nuovo file modello viene aggiunto, Dsl\GeneratedCode\ModelBusReferencesSerialization.tt.

Quando si imposta il tipo di proprietà del dominio a ModelBusReference quindi fare clic con il pulsante destro del mouse sulla proprietà e scegliere Abilitazione delle proprietà specifiche di ModelBusReference:

• Diversi attributi CLR vengono aggiunti alla proprietà del dominio.È possibile visualizzarle negli attributi personalizzati il campo nella Finestra Proprietà.in Dsl\GeneratedCode\DomainClasses.cs, è possibile esaminarne gli attributi nella dichiarazione della proprietà:

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

Quando si fa clic con il pulsante destro del mouse sul diagramma della definizione di modello DSL, fare clic su abilitare ModelBuse selezionare Esporre il modello DSL a ModelBus:

• un nuovo progetto ModelBusAdapter aggiunto alla soluzione.

• un riferimento a ModelBusAdapter l'oggetto viene aggiunto a DslPackage progetto.ModelBusAdapter include un riferimento a Dsl progetto.

• in DslPackage\source.extention.tt, |ModelBusAdapter| viene aggiunto come componente MEF.

Vedere anche

Concetti

Procedura: aprire un modello da file nel codice del programma

Procedura: integrare i modelli UML con altri modelli e strumenti

Procedura: aggiungere un gestore di trascinamento della selezione

Utilizzo di ModelBus di Visual Studio in un modello di testo